2 * Adaptec AAC series RAID controller driver
3 * (c) Copyright 2001 Red Hat Inc. <alan@redhat.com>
5 * based on the old aacraid driver that is..
6 * Adaptec aacraid device driver for Linux.
8 * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
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)
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.
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.
27 * Abstract: Contain all routines that are required for FSA host/adapter
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_host.h>
44 #include <scsi/scsi_device.h>
45 #include <asm/semaphore.h>
50 * fib_map_alloc - allocate the fib objects
51 * @dev: Adapter to allocate for
53 * Allocate and map the shared PCI space for the FIB blocks used to
54 * talk to the Adaptec firmware.
57 static int fib_map_alloc(struct aac_dev *dev)
60 "allocate hardware fibs pci_alloc_consistent(%p, %d * (%d + %d), %p)\n",
61 dev->pdev, dev->max_fib_size, dev->scsi_host_ptr->can_queue,
62 AAC_NUM_MGT_FIB, &dev->hw_fib_pa));
63 if((dev->hw_fib_va = pci_alloc_consistent(dev->pdev, dev->max_fib_size
64 * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB),
65 &dev->hw_fib_pa))==NULL)
71 * aac_fib_map_free - free the fib objects
72 * @dev: Adapter to free
74 * Free the PCI mappings and the memory allocated for FIB blocks
78 void aac_fib_map_free(struct aac_dev *dev)
80 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);
84 * aac_fib_setup - setup the fibs
85 * @dev: Adapter to set up
87 * Allocate the PCI space for the fibs, map it and then intialise the
88 * fib area, the unmapped fib data and also the free list
91 int aac_fib_setup(struct aac_dev * dev)
94 struct hw_fib *hw_fib_va;
98 while (((i = fib_map_alloc(dev)) == -ENOMEM)
99 && (dev->scsi_host_ptr->can_queue > (64 - AAC_NUM_MGT_FIB))) {
100 dev->init->MaxIoCommands = cpu_to_le32((dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB) >> 1);
101 dev->scsi_host_ptr->can_queue = le32_to_cpu(dev->init->MaxIoCommands) - AAC_NUM_MGT_FIB;
106 hw_fib_va = dev->hw_fib_va;
107 hw_fib_pa = dev->hw_fib_pa;
108 memset(hw_fib_va, 0, dev->max_fib_size * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB));
110 * Initialise the fibs
112 for (i = 0, fibptr = &dev->fibs[i]; i < (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); i++, fibptr++)
115 fibptr->hw_fib = hw_fib_va;
116 fibptr->data = (void *) fibptr->hw_fib->data;
117 fibptr->next = fibptr+1; /* Forward chain the fibs */
118 init_MUTEX_LOCKED(&fibptr->event_wait);
119 spin_lock_init(&fibptr->event_lock);
120 hw_fib_va->header.XferState = cpu_to_le32(0xffffffff);
121 hw_fib_va->header.SenderSize = cpu_to_le16(dev->max_fib_size);
122 fibptr->hw_fib_pa = hw_fib_pa;
123 hw_fib_va = (struct hw_fib *)((unsigned char *)hw_fib_va + dev->max_fib_size);
124 hw_fib_pa = hw_fib_pa + dev->max_fib_size;
127 * Add the fib chain to the free list
129 dev->fibs[dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB - 1].next = NULL;
131 * Enable this to debug out of queue space
133 dev->free_fib = &dev->fibs[0];
138 * aac_fib_alloc - allocate a fib
139 * @dev: Adapter to allocate the fib for
141 * Allocate a fib from the adapter fib pool. If the pool is empty we
145 struct fib *aac_fib_alloc(struct aac_dev *dev)
149 spin_lock_irqsave(&dev->fib_lock, flags);
150 fibptr = dev->free_fib;
152 spin_unlock_irqrestore(&dev->fib_lock, flags);
155 dev->free_fib = fibptr->next;
156 spin_unlock_irqrestore(&dev->fib_lock, flags);
158 * Set the proper node type code and node byte size
160 fibptr->type = FSAFS_NTC_FIB_CONTEXT;
161 fibptr->size = sizeof(struct fib);
163 * Null out fields that depend on being zero at the start of
166 fibptr->hw_fib->header.XferState = 0;
167 fibptr->callback = NULL;
168 fibptr->callback_data = NULL;
174 * aac_fib_free - free a fib
175 * @fibptr: fib to free up
177 * Frees up a fib and places it on the appropriate queue
178 * (either free or timed out)
181 void aac_fib_free(struct fib *fibptr)
185 spin_lock_irqsave(&fibptr->dev->fib_lock, flags);
186 if (fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT) {
187 aac_config.fib_timeouts++;
188 fibptr->next = fibptr->dev->timeout_fib;
189 fibptr->dev->timeout_fib = fibptr;
191 if (fibptr->hw_fib->header.XferState != 0) {
192 printk(KERN_WARNING "aac_fib_free, XferState != 0, fibptr = 0x%p, XferState = 0x%x\n",
194 le32_to_cpu(fibptr->hw_fib->header.XferState));
196 fibptr->next = fibptr->dev->free_fib;
197 fibptr->dev->free_fib = fibptr;
199 spin_unlock_irqrestore(&fibptr->dev->fib_lock, flags);
203 * aac_fib_init - initialise a fib
204 * @fibptr: The fib to initialize
206 * Set up the generic fib fields ready for use
209 void aac_fib_init(struct fib *fibptr)
211 struct hw_fib *hw_fib = fibptr->hw_fib;
213 hw_fib->header.StructType = FIB_MAGIC;
214 hw_fib->header.Size = cpu_to_le16(fibptr->dev->max_fib_size);
215 hw_fib->header.XferState = cpu_to_le32(HostOwned | FibInitialized | FibEmpty | FastResponseCapable);
216 hw_fib->header.SenderFibAddress = 0; /* Filled in later if needed */
217 hw_fib->header.ReceiverFibAddress = cpu_to_le32(fibptr->hw_fib_pa);
218 hw_fib->header.SenderSize = cpu_to_le16(fibptr->dev->max_fib_size);
222 * fib_deallocate - deallocate a fib
223 * @fibptr: fib to deallocate
225 * Will deallocate and return to the free pool the FIB pointed to by the
229 static void fib_dealloc(struct fib * fibptr)
231 struct hw_fib *hw_fib = fibptr->hw_fib;
232 BUG_ON(hw_fib->header.StructType != FIB_MAGIC);
233 hw_fib->header.XferState = 0;
237 * Commuication primitives define and support the queuing method we use to
238 * support host to adapter commuication. All queue accesses happen through
239 * these routines and are the only routines which have a knowledge of the
240 * how these queues are implemented.
244 * aac_get_entry - get a queue entry
247 * @entry: Entry return
248 * @index: Index return
249 * @nonotify: notification control
251 * With a priority the routine returns a queue entry if the queue has free entries. If the queue
252 * is full(no free entries) than no entry is returned and the function returns 0 otherwise 1 is
256 static int aac_get_entry (struct aac_dev * dev, u32 qid, struct aac_entry **entry, u32 * index, unsigned long *nonotify)
258 struct aac_queue * q;
262 * All of the queues wrap when they reach the end, so we check
263 * to see if they have reached the end and if they have we just
264 * set the index back to zero. This is a wrap. You could or off
265 * the high bits in all updates but this is a bit faster I think.
268 q = &dev->queues->queue[qid];
270 idx = *index = le32_to_cpu(*(q->headers.producer));
271 /* Interrupt Moderation, only interrupt for first two entries */
272 if (idx != le32_to_cpu(*(q->headers.consumer))) {
274 if (qid == AdapNormCmdQueue)
275 idx = ADAP_NORM_CMD_ENTRIES;
277 idx = ADAP_NORM_RESP_ENTRIES;
279 if (idx != le32_to_cpu(*(q->headers.consumer)))
283 if (qid == AdapNormCmdQueue) {
284 if (*index >= ADAP_NORM_CMD_ENTRIES)
285 *index = 0; /* Wrap to front of the Producer Queue. */
287 if (*index >= ADAP_NORM_RESP_ENTRIES)
288 *index = 0; /* Wrap to front of the Producer Queue. */
291 if ((*index + 1) == le32_to_cpu(*(q->headers.consumer))) { /* Queue is full */
292 printk(KERN_WARNING "Queue %d full, %u outstanding.\n",
296 *entry = q->base + *index;
302 * aac_queue_get - get the next free QE
304 * @index: Returned index
305 * @priority: Priority of fib
306 * @fib: Fib to associate with the queue entry
307 * @wait: Wait if queue full
308 * @fibptr: Driver fib object to go with fib
309 * @nonotify: Don't notify the adapter
311 * Gets the next free QE off the requested priorty adapter command
312 * queue and associates the Fib with the QE. The QE represented by
313 * index is ready to insert on the queue when this routine returns
317 static 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)
319 struct aac_entry * entry = NULL;
322 if (qid == AdapNormCmdQueue) {
323 /* if no entries wait for some if caller wants to */
324 while (!aac_get_entry(dev, qid, &entry, index, nonotify))
326 printk(KERN_ERR "GetEntries failed\n");
329 * Setup queue entry with a command, status and fib mapped
331 entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size));
334 while(!aac_get_entry(dev, qid, &entry, index, nonotify))
336 /* if no entries wait for some if caller wants to */
339 * Setup queue entry with command, status and fib mapped
341 entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size));
342 entry->addr = hw_fib->header.SenderFibAddress;
343 /* Restore adapters pointer to the FIB */
344 hw_fib->header.ReceiverFibAddress = hw_fib->header.SenderFibAddress; /* Let the adapter now where to find its data */
348 * If MapFib is true than we need to map the Fib and put pointers
349 * in the queue entry.
352 entry->addr = cpu_to_le32(fibptr->hw_fib_pa);
357 * Define the highest level of host to adapter communication routines.
358 * These routines will support host to adapter FS commuication. These
359 * routines have no knowledge of the commuication method used. This level
360 * sends and receives FIBs. This level has no knowledge of how these FIBs
361 * get passed back and forth.
365 * aac_fib_send - send a fib to the adapter
366 * @command: Command to send
368 * @size: Size of fib data area
369 * @priority: Priority of Fib
370 * @wait: Async/sync select
371 * @reply: True if a reply is wanted
372 * @callback: Called with reply
373 * @callback_data: Passed to callback
375 * Sends the requested FIB to the adapter and optionally will wait for a
376 * response FIB. If the caller does not wish to wait for a response than
377 * an event to wait on must be supplied. This event will be set when a
378 * response FIB is received from the adapter.
381 int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
382 int priority, int wait, int reply, fib_callback callback,
385 struct aac_dev * dev = fibptr->dev;
386 struct hw_fib * hw_fib = fibptr->hw_fib;
387 struct aac_queue * q;
388 unsigned long flags = 0;
389 unsigned long qflags;
391 if (!(hw_fib->header.XferState & cpu_to_le32(HostOwned)))
394 * There are 5 cases with the wait and reponse requested flags.
395 * The only invalid cases are if the caller requests to wait and
396 * does not request a response and if the caller does not want a
397 * response and the Fib is not allocated from pool. If a response
398 * is not requesed the Fib will just be deallocaed by the DPC
399 * routine when the response comes back from the adapter. No
400 * further processing will be done besides deleting the Fib. We
401 * will have a debug mode where the adapter can notify the host
402 * it had a problem and the host can log that fact.
404 if (wait && !reply) {
406 } else if (!wait && reply) {
407 hw_fib->header.XferState |= cpu_to_le32(Async | ResponseExpected);
408 FIB_COUNTER_INCREMENT(aac_config.AsyncSent);
409 } else if (!wait && !reply) {
410 hw_fib->header.XferState |= cpu_to_le32(NoResponseExpected);
411 FIB_COUNTER_INCREMENT(aac_config.NoResponseSent);
412 } else if (wait && reply) {
413 hw_fib->header.XferState |= cpu_to_le32(ResponseExpected);
414 FIB_COUNTER_INCREMENT(aac_config.NormalSent);
417 * Map the fib into 32bits by using the fib number
420 hw_fib->header.SenderFibAddress = cpu_to_le32(((u32)(fibptr - dev->fibs)) << 2);
421 hw_fib->header.SenderData = (u32)(fibptr - dev->fibs);
423 * Set FIB state to indicate where it came from and if we want a
424 * response from the adapter. Also load the command from the
427 * Map the hw fib pointer as a 32bit value
429 hw_fib->header.Command = cpu_to_le16(command);
430 hw_fib->header.XferState |= cpu_to_le32(SentFromHost);
431 fibptr->hw_fib->header.Flags = 0; /* 0 the flags field - internal only*/
433 * Set the size of the Fib we want to send to the adapter
435 hw_fib->header.Size = cpu_to_le16(sizeof(struct aac_fibhdr) + size);
436 if (le16_to_cpu(hw_fib->header.Size) > le16_to_cpu(hw_fib->header.SenderSize)) {
440 * Get a queue entry connect the FIB to it and send an notify
441 * the adapter a command is ready.
443 hw_fib->header.XferState |= cpu_to_le32(NormalPriority);
446 * Fill in the Callback and CallbackContext if we are not
450 fibptr->callback = callback;
451 fibptr->callback_data = callback_data;
457 FIB_COUNTER_INCREMENT(aac_config.FibsSent);
459 dprintk((KERN_DEBUG "Fib contents:.\n"));
460 dprintk((KERN_DEBUG " Command = %d.\n", le32_to_cpu(hw_fib->header.Command)));
461 dprintk((KERN_DEBUG " SubCommand = %d.\n", le32_to_cpu(((struct aac_query_mount *)fib_data(fibptr))->command)));
462 dprintk((KERN_DEBUG " XferState = %x.\n", le32_to_cpu(hw_fib->header.XferState)));
463 dprintk((KERN_DEBUG " hw_fib va being sent=%p\n",fibptr->hw_fib));
464 dprintk((KERN_DEBUG " hw_fib pa being sent=%lx\n",(ulong)fibptr->hw_fib_pa));
465 dprintk((KERN_DEBUG " fib being sent=%p\n",fibptr));
469 q = &dev->queues->queue[AdapNormCmdQueue];
472 spin_lock_irqsave(&fibptr->event_lock, flags);
473 spin_lock_irqsave(q->lock, qflags);
474 if (dev->new_comm_interface) {
475 unsigned long count = 10000000L; /* 50 seconds */
477 spin_unlock_irqrestore(q->lock, qflags);
478 while (aac_adapter_send(fibptr) != 0) {
481 spin_unlock_irqrestore(&fibptr->event_lock, flags);
482 spin_lock_irqsave(q->lock, qflags);
484 spin_unlock_irqrestore(q->lock, qflags);
491 unsigned long nointr = 0;
492 aac_queue_get( dev, &index, AdapNormCmdQueue, hw_fib, 1, fibptr, &nointr);
495 *(q->headers.producer) = cpu_to_le32(index + 1);
496 spin_unlock_irqrestore(q->lock, qflags);
497 dprintk((KERN_DEBUG "aac_fib_send: inserting a queue entry at index %d.\n",index));
498 if (!(nointr & aac_config.irq_mod))
499 aac_adapter_notify(dev, AdapNormCmdQueue);
503 * If the caller wanted us to wait for response wait now.
507 spin_unlock_irqrestore(&fibptr->event_lock, flags);
508 /* Only set for first known interruptable command */
511 * *VERY* Dangerous to time out a command, the
512 * assumption is made that we have no hope of
513 * functioning because an interrupt routing or other
514 * hardware failure has occurred.
516 unsigned long count = 36000000L; /* 3 minutes */
517 while (down_trylock(&fibptr->event_wait)) {
519 spin_lock_irqsave(q->lock, qflags);
521 spin_unlock_irqrestore(q->lock, qflags);
523 printk(KERN_ERR "aacraid: aac_fib_send: first asynchronous command timed out.\n"
524 "Usually a result of a PCI interrupt routing problem;\n"
525 "update mother board BIOS or consider utilizing one of\n"
526 "the SAFE mode kernel options (acpi, apic etc)\n");
532 } else if (down_interruptible(&fibptr->event_wait)) {
533 spin_lock_irqsave(&fibptr->event_lock, flags);
534 if (fibptr->done == 0) {
535 fibptr->done = 2; /* Tell interrupt we aborted */
536 spin_unlock_irqrestore(&fibptr->event_lock, flags);
539 spin_unlock_irqrestore(&fibptr->event_lock, flags);
541 BUG_ON(fibptr->done == 0);
543 if((fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT)){
550 * If the user does not want a response than return success otherwise
560 * aac_consumer_get - get the top of the queue
563 * @entry: Return entry
565 * Will return a pointer to the entry on the top of the queue requested that
566 * we are a consumer of, and return the address of the queue entry. It does
567 * not change the state of the queue.
570 int aac_consumer_get(struct aac_dev * dev, struct aac_queue * q, struct aac_entry **entry)
574 if (le32_to_cpu(*q->headers.producer) == le32_to_cpu(*q->headers.consumer)) {
578 * The consumer index must be wrapped if we have reached
579 * the end of the queue, else we just use the entry
580 * pointed to by the header index
582 if (le32_to_cpu(*q->headers.consumer) >= q->entries)
585 index = le32_to_cpu(*q->headers.consumer);
586 *entry = q->base + index;
593 * aac_consumer_free - free consumer entry
598 * Frees up the current top of the queue we are a consumer of. If the
599 * queue was full notify the producer that the queue is no longer full.
602 void aac_consumer_free(struct aac_dev * dev, struct aac_queue *q, u32 qid)
607 if ((le32_to_cpu(*q->headers.producer)+1) == le32_to_cpu(*q->headers.consumer))
610 if (le32_to_cpu(*q->headers.consumer) >= q->entries)
611 *q->headers.consumer = cpu_to_le32(1);
613 *q->headers.consumer = cpu_to_le32(le32_to_cpu(*q->headers.consumer)+1);
618 case HostNormCmdQueue:
619 notify = HostNormCmdNotFull;
621 case HostNormRespQueue:
622 notify = HostNormRespNotFull;
628 aac_adapter_notify(dev, notify);
633 * aac_fib_adapter_complete - complete adapter issued fib
634 * @fibptr: fib to complete
637 * Will do all necessary work to complete a FIB that was sent from
641 int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size)
643 struct hw_fib * hw_fib = fibptr->hw_fib;
644 struct aac_dev * dev = fibptr->dev;
645 struct aac_queue * q;
646 unsigned long nointr = 0;
647 unsigned long qflags;
649 if (hw_fib->header.XferState == 0) {
650 if (dev->new_comm_interface)
655 * If we plan to do anything check the structure type first.
657 if ( hw_fib->header.StructType != FIB_MAGIC ) {
658 if (dev->new_comm_interface)
663 * This block handles the case where the adapter had sent us a
664 * command and we have finished processing the command. We
665 * call completeFib when we are done processing the command
666 * and want to send a response back to the adapter. This will
667 * send the completed cdb to the adapter.
669 if (hw_fib->header.XferState & cpu_to_le32(SentFromAdapter)) {
670 if (dev->new_comm_interface) {
674 hw_fib->header.XferState |= cpu_to_le32(HostProcessed);
676 size += sizeof(struct aac_fibhdr);
677 if (size > le16_to_cpu(hw_fib->header.SenderSize))
679 hw_fib->header.Size = cpu_to_le16(size);
681 q = &dev->queues->queue[AdapNormRespQueue];
682 spin_lock_irqsave(q->lock, qflags);
683 aac_queue_get(dev, &index, AdapNormRespQueue, hw_fib, 1, NULL, &nointr);
684 *(q->headers.producer) = cpu_to_le32(index + 1);
685 spin_unlock_irqrestore(q->lock, qflags);
686 if (!(nointr & (int)aac_config.irq_mod))
687 aac_adapter_notify(dev, AdapNormRespQueue);
692 printk(KERN_WARNING "aac_fib_adapter_complete: Unknown xferstate detected.\n");
699 * aac_fib_complete - fib completion handler
700 * @fib: FIB to complete
702 * Will do all necessary work to complete a FIB.
705 int aac_fib_complete(struct fib *fibptr)
707 struct hw_fib * hw_fib = fibptr->hw_fib;
710 * Check for a fib which has already been completed
713 if (hw_fib->header.XferState == 0)
716 * If we plan to do anything check the structure type first.
719 if (hw_fib->header.StructType != FIB_MAGIC)
722 * This block completes a cdb which orginated on the host and we
723 * just need to deallocate the cdb or reinit it. At this point the
724 * command is complete that we had sent to the adapter and this
725 * cdb could be reused.
727 if((hw_fib->header.XferState & cpu_to_le32(SentFromHost)) &&
728 (hw_fib->header.XferState & cpu_to_le32(AdapterProcessed)))
732 else if(hw_fib->header.XferState & cpu_to_le32(SentFromHost))
735 * This handles the case when the host has aborted the I/O
736 * to the adapter because the adapter is not responding
739 } else if(hw_fib->header.XferState & cpu_to_le32(HostOwned)) {
748 * aac_printf - handle printf from firmware
752 * Print a message passed to us by the controller firmware on the
756 void aac_printf(struct aac_dev *dev, u32 val)
758 char *cp = dev->printfbuf;
759 if (dev->printf_enabled)
761 int length = val & 0xffff;
762 int level = (val >> 16) & 0xffff;
765 * The size of the printfbuf is set in port.c
766 * There is no variable or define for it
772 if (level == LOG_AAC_HIGH_ERROR)
773 printk(KERN_WARNING "%s:%s", dev->name, cp);
775 printk(KERN_INFO "%s:%s", dev->name, cp);
782 * aac_handle_aif - Handle a message from the firmware
783 * @dev: Which adapter this fib is from
784 * @fibptr: Pointer to fibptr from adapter
786 * This routine handles a driver notify fib from the adapter and
787 * dispatches it to the appropriate routine for handling.
790 #define AIF_SNIFF_TIMEOUT (30*HZ)
791 static void aac_handle_aif(struct aac_dev * dev, struct fib * fibptr)
793 struct hw_fib * hw_fib = fibptr->hw_fib;
794 struct aac_aifcmd * aifcmd = (struct aac_aifcmd *)hw_fib->data;
797 struct scsi_device *device;
803 } device_config_needed;
805 /* Sniff for container changes */
807 if (!dev || !dev->fsa_dev)
812 * We have set this up to try and minimize the number of
813 * re-configures that take place. As a result of this when
814 * certain AIF's come in we will set a flag waiting for another
815 * type of AIF before setting the re-config flag.
817 switch (le32_to_cpu(aifcmd->command)) {
818 case AifCmdDriverNotify:
819 switch (le32_to_cpu(((u32 *)aifcmd->data)[0])) {
821 * Morph or Expand complete
823 case AifDenMorphComplete:
824 case AifDenVolumeExtendComplete:
825 container = le32_to_cpu(((u32 *)aifcmd->data)[1]);
826 if (container >= dev->maximum_num_containers)
830 * Find the scsi_device associated with the SCSI
831 * address. Make sure we have the right array, and if
832 * so set the flag to initiate a new re-config once we
833 * see an AifEnConfigChange AIF come through.
836 if ((dev != NULL) && (dev->scsi_host_ptr != NULL)) {
837 device = scsi_device_lookup(dev->scsi_host_ptr,
838 CONTAINER_TO_CHANNEL(container),
839 CONTAINER_TO_ID(container),
840 CONTAINER_TO_LUN(container));
842 dev->fsa_dev[container].config_needed = CHANGE;
843 dev->fsa_dev[container].config_waiting_on = AifEnConfigChange;
844 dev->fsa_dev[container].config_waiting_stamp = jiffies;
845 scsi_device_put(device);
851 * If we are waiting on something and this happens to be
852 * that thing then set the re-configure flag.
854 if (container != (u32)-1) {
855 if (container >= dev->maximum_num_containers)
857 if ((dev->fsa_dev[container].config_waiting_on ==
858 le32_to_cpu(*(u32 *)aifcmd->data)) &&
859 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
860 dev->fsa_dev[container].config_waiting_on = 0;
861 } else for (container = 0;
862 container < dev->maximum_num_containers; ++container) {
863 if ((dev->fsa_dev[container].config_waiting_on ==
864 le32_to_cpu(*(u32 *)aifcmd->data)) &&
865 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
866 dev->fsa_dev[container].config_waiting_on = 0;
870 case AifCmdEventNotify:
871 switch (le32_to_cpu(((u32 *)aifcmd->data)[0])) {
875 case AifEnAddContainer:
876 container = le32_to_cpu(((u32 *)aifcmd->data)[1]);
877 if (container >= dev->maximum_num_containers)
879 dev->fsa_dev[container].config_needed = ADD;
880 dev->fsa_dev[container].config_waiting_on =
882 dev->fsa_dev[container].config_waiting_stamp = jiffies;
888 case AifEnDeleteContainer:
889 container = le32_to_cpu(((u32 *)aifcmd->data)[1]);
890 if (container >= dev->maximum_num_containers)
892 dev->fsa_dev[container].config_needed = DELETE;
893 dev->fsa_dev[container].config_waiting_on =
895 dev->fsa_dev[container].config_waiting_stamp = jiffies;
899 * Container change detected. If we currently are not
900 * waiting on something else, setup to wait on a Config Change.
902 case AifEnContainerChange:
903 container = le32_to_cpu(((u32 *)aifcmd->data)[1]);
904 if (container >= dev->maximum_num_containers)
906 if (dev->fsa_dev[container].config_waiting_on &&
907 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
909 dev->fsa_dev[container].config_needed = CHANGE;
910 dev->fsa_dev[container].config_waiting_on =
912 dev->fsa_dev[container].config_waiting_stamp = jiffies;
915 case AifEnConfigChange:
921 * If we are waiting on something and this happens to be
922 * that thing then set the re-configure flag.
924 if (container != (u32)-1) {
925 if (container >= dev->maximum_num_containers)
927 if ((dev->fsa_dev[container].config_waiting_on ==
928 le32_to_cpu(*(u32 *)aifcmd->data)) &&
929 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
930 dev->fsa_dev[container].config_waiting_on = 0;
931 } else for (container = 0;
932 container < dev->maximum_num_containers; ++container) {
933 if ((dev->fsa_dev[container].config_waiting_on ==
934 le32_to_cpu(*(u32 *)aifcmd->data)) &&
935 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
936 dev->fsa_dev[container].config_waiting_on = 0;
940 case AifCmdJobProgress:
942 * These are job progress AIF's. When a Clear is being
943 * done on a container it is initially created then hidden from
944 * the OS. When the clear completes we don't get a config
945 * change so we monitor the job status complete on a clear then
946 * wait for a container change.
949 if ((((u32 *)aifcmd->data)[1] == cpu_to_le32(AifJobCtrZero))
950 && ((((u32 *)aifcmd->data)[6] == ((u32 *)aifcmd->data)[5])
951 || (((u32 *)aifcmd->data)[4] == cpu_to_le32(AifJobStsSuccess)))) {
953 container < dev->maximum_num_containers;
956 * Stomp on all config sequencing for all
959 dev->fsa_dev[container].config_waiting_on =
960 AifEnContainerChange;
961 dev->fsa_dev[container].config_needed = ADD;
962 dev->fsa_dev[container].config_waiting_stamp =
966 if ((((u32 *)aifcmd->data)[1] == cpu_to_le32(AifJobCtrZero))
967 && (((u32 *)aifcmd->data)[6] == 0)
968 && (((u32 *)aifcmd->data)[4] == cpu_to_le32(AifJobStsRunning))) {
970 container < dev->maximum_num_containers;
973 * Stomp on all config sequencing for all
976 dev->fsa_dev[container].config_waiting_on =
977 AifEnContainerChange;
978 dev->fsa_dev[container].config_needed = DELETE;
979 dev->fsa_dev[container].config_waiting_stamp =
986 device_config_needed = NOTHING;
987 for (container = 0; container < dev->maximum_num_containers;
989 if ((dev->fsa_dev[container].config_waiting_on == 0) &&
990 (dev->fsa_dev[container].config_needed != NOTHING) &&
991 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) {
992 device_config_needed =
993 dev->fsa_dev[container].config_needed;
994 dev->fsa_dev[container].config_needed = NOTHING;
998 if (device_config_needed == NOTHING)
1002 * If we decided that a re-configuration needs to be done,
1003 * schedule it here on the way out the door, please close the door
1011 * Find the scsi_device associated with the SCSI address,
1012 * and mark it as changed, invalidating the cache. This deals
1013 * with changes to existing device IDs.
1016 if (!dev || !dev->scsi_host_ptr)
1019 * force reload of disk info via aac_probe_container
1021 if ((device_config_needed == CHANGE)
1022 && (dev->fsa_dev[container].valid == 1))
1023 dev->fsa_dev[container].valid = 2;
1024 if ((device_config_needed == CHANGE) ||
1025 (device_config_needed == ADD))
1026 aac_probe_container(dev, container);
1027 device = scsi_device_lookup(dev->scsi_host_ptr,
1028 CONTAINER_TO_CHANNEL(container),
1029 CONTAINER_TO_ID(container),
1030 CONTAINER_TO_LUN(container));
1032 switch (device_config_needed) {
1034 scsi_remove_device(device);
1037 if (!dev->fsa_dev[container].valid) {
1038 scsi_remove_device(device);
1041 scsi_rescan_device(&device->sdev_gendev);
1046 scsi_device_put(device);
1048 if (device_config_needed == ADD) {
1049 scsi_add_device(dev->scsi_host_ptr,
1050 CONTAINER_TO_CHANNEL(container),
1051 CONTAINER_TO_ID(container),
1052 CONTAINER_TO_LUN(container));
1058 * aac_command_thread - command processing thread
1059 * @dev: Adapter to monitor
1061 * Waits on the commandready event in it's queue. When the event gets set
1062 * it will pull FIBs off it's queue. It will continue to pull FIBs off
1063 * until the queue is empty. When the queue is empty it will wait for
1067 int aac_command_thread(void *data)
1069 struct aac_dev *dev = data;
1070 struct hw_fib *hw_fib, *hw_newfib;
1071 struct fib *fib, *newfib;
1072 struct aac_fib_context *fibctx;
1073 unsigned long flags;
1074 DECLARE_WAITQUEUE(wait, current);
1077 * We can only have one thread per adapter for AIF's.
1079 if (dev->aif_thread)
1083 * Let the DPC know it has a place to send the AIF's to.
1085 dev->aif_thread = 1;
1086 add_wait_queue(&dev->queues->queue[HostNormCmdQueue].cmdready, &wait);
1087 set_current_state(TASK_INTERRUPTIBLE);
1088 dprintk ((KERN_INFO "aac_command_thread start\n"));
1091 spin_lock_irqsave(dev->queues->queue[HostNormCmdQueue].lock, flags);
1092 while(!list_empty(&(dev->queues->queue[HostNormCmdQueue].cmdq))) {
1093 struct list_head *entry;
1094 struct aac_aifcmd * aifcmd;
1096 set_current_state(TASK_RUNNING);
1098 entry = dev->queues->queue[HostNormCmdQueue].cmdq.next;
1101 spin_unlock_irqrestore(dev->queues->queue[HostNormCmdQueue].lock, flags);
1102 fib = list_entry(entry, struct fib, fiblink);
1104 * We will process the FIB here or pass it to a
1105 * worker thread that is TBD. We Really can't
1106 * do anything at this point since we don't have
1107 * anything defined for this thread to do.
1109 hw_fib = fib->hw_fib;
1110 memset(fib, 0, sizeof(struct fib));
1111 fib->type = FSAFS_NTC_FIB_CONTEXT;
1112 fib->size = sizeof( struct fib );
1113 fib->hw_fib = hw_fib;
1114 fib->data = hw_fib->data;
1117 * We only handle AifRequest fibs from the adapter.
1119 aifcmd = (struct aac_aifcmd *) hw_fib->data;
1120 if (aifcmd->command == cpu_to_le32(AifCmdDriverNotify)) {
1121 /* Handle Driver Notify Events */
1122 aac_handle_aif(dev, fib);
1123 *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK);
1124 aac_fib_adapter_complete(fib, (u16)sizeof(u32));
1126 struct list_head *entry;
1127 /* The u32 here is important and intended. We are using
1128 32bit wrapping time to fit the adapter field */
1130 u32 time_now, time_last;
1131 unsigned long flagv;
1133 struct hw_fib ** hw_fib_pool, ** hw_fib_p;
1134 struct fib ** fib_pool, ** fib_p;
1137 if ((aifcmd->command ==
1138 cpu_to_le32(AifCmdEventNotify)) ||
1140 cpu_to_le32(AifCmdJobProgress))) {
1141 aac_handle_aif(dev, fib);
1144 time_now = jiffies/HZ;
1147 * Warning: no sleep allowed while
1148 * holding spinlock. We take the estimate
1149 * and pre-allocate a set of fibs outside the
1152 num = le32_to_cpu(dev->init->AdapterFibsSize)
1153 / sizeof(struct hw_fib); /* some extra */
1154 spin_lock_irqsave(&dev->fib_lock, flagv);
1155 entry = dev->fib_list.next;
1156 while (entry != &dev->fib_list) {
1157 entry = entry->next;
1160 spin_unlock_irqrestore(&dev->fib_lock, flagv);
1164 && ((hw_fib_pool = kmalloc(sizeof(struct hw_fib *) * num, GFP_KERNEL)))
1165 && ((fib_pool = kmalloc(sizeof(struct fib *) * num, GFP_KERNEL)))) {
1166 hw_fib_p = hw_fib_pool;
1168 while (hw_fib_p < &hw_fib_pool[num]) {
1169 if (!(*(hw_fib_p++) = kmalloc(sizeof(struct hw_fib), GFP_KERNEL))) {
1173 if (!(*(fib_p++) = kmalloc(sizeof(struct fib), GFP_KERNEL))) {
1174 kfree(*(--hw_fib_p));
1178 if ((num = hw_fib_p - hw_fib_pool) == 0) {
1188 spin_lock_irqsave(&dev->fib_lock, flagv);
1189 entry = dev->fib_list.next;
1191 * For each Context that is on the
1192 * fibctxList, make a copy of the
1193 * fib, and then set the event to wake up the
1194 * thread that is waiting for it.
1196 hw_fib_p = hw_fib_pool;
1198 while (entry != &dev->fib_list) {
1200 * Extract the fibctx
1202 fibctx = list_entry(entry, struct aac_fib_context, next);
1204 * Check if the queue is getting
1207 if (fibctx->count > 20)
1210 * It's *not* jiffies folks,
1211 * but jiffies / HZ so do not
1214 time_last = fibctx->jiffies;
1216 * Has it been > 2 minutes
1217 * since the last read off
1220 if ((time_now - time_last) > aif_timeout) {
1221 entry = entry->next;
1222 aac_close_fib_context(dev, fibctx);
1227 * Warning: no sleep allowed while
1230 if (hw_fib_p < &hw_fib_pool[num]) {
1231 hw_newfib = *hw_fib_p;
1232 *(hw_fib_p++) = NULL;
1236 * Make the copy of the FIB
1238 memcpy(hw_newfib, hw_fib, sizeof(struct hw_fib));
1239 memcpy(newfib, fib, sizeof(struct fib));
1240 newfib->hw_fib = hw_newfib;
1242 * Put the FIB onto the
1245 list_add_tail(&newfib->fiblink, &fibctx->fib_list);
1248 * Set the event to wake up the
1249 * thread that is waiting.
1251 up(&fibctx->wait_sem);
1253 printk(KERN_WARNING "aifd: didn't allocate NewFib.\n");
1255 entry = entry->next;
1258 * Set the status of this FIB
1260 *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK);
1261 aac_fib_adapter_complete(fib, sizeof(u32));
1262 spin_unlock_irqrestore(&dev->fib_lock, flagv);
1263 /* Free up the remaining resources */
1264 hw_fib_p = hw_fib_pool;
1266 while (hw_fib_p < &hw_fib_pool[num]) {
1276 spin_lock_irqsave(dev->queues->queue[HostNormCmdQueue].lock, flags);
1279 * There are no more AIF's
1281 spin_unlock_irqrestore(dev->queues->queue[HostNormCmdQueue].lock, flags);
1284 if (kthread_should_stop())
1286 set_current_state(TASK_INTERRUPTIBLE);
1289 remove_wait_queue(&dev->queues->queue[HostNormCmdQueue].cmdready, &wait);
1290 dev->aif_thread = 0;