2 * Adaptec AAC series RAID controller driver
3 * (c) Copyright 2001 Red Hat Inc.
5 * based on the old aacraid driver that is..
6 * Adaptec aacraid device driver for Linux.
8 * Copyright (c) 2000-2010 Adaptec, Inc.
9 * 2010 PMC-Sierra, Inc. (aacraid@pmc-sierra.com)
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)
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.
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.
28 * Abstract: Contain all routines that are required for FSA host/adapter
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>
54 * fib_map_alloc - allocate the fib objects
55 * @dev: Adapter to allocate for
57 * Allocate and map the shared PCI space for the FIB blocks used to
58 * talk to the Adaptec firmware.
61 static int fib_map_alloc(struct aac_dev
*dev
)
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),
71 if (dev
->hw_fib_va
== NULL
)
77 * aac_fib_map_free - free the fib objects
78 * @dev: Adapter to free
80 * Free the PCI mappings and the memory allocated for FIB blocks
84 void aac_fib_map_free(struct aac_dev
*dev
)
86 if (dev
->hw_fib_va
&& dev
->max_fib_size
) {
87 pci_free_consistent(dev
->pdev
,
89 (dev
->scsi_host_ptr
->can_queue
+ AAC_NUM_MGT_FIB
)),
90 dev
->hw_fib_va
, dev
->hw_fib_pa
);
92 dev
->hw_fib_va
= NULL
;
96 void aac_fib_vector_assign(struct aac_dev
*dev
)
100 struct fib
*fibptr
= NULL
;
102 for (i
= 0, fibptr
= &dev
->fibs
[i
];
103 i
< (dev
->scsi_host_ptr
->can_queue
+ AAC_NUM_MGT_FIB
);
105 if ((dev
->max_msix
== 1) ||
106 (i
> ((dev
->scsi_host_ptr
->can_queue
+ AAC_NUM_MGT_FIB
- 1)
107 - dev
->vector_cap
))) {
108 fibptr
->vector_no
= 0;
110 fibptr
->vector_no
= vector
;
112 if (vector
== dev
->max_msix
)
119 * aac_fib_setup - setup the fibs
120 * @dev: Adapter to set up
122 * Allocate the PCI space for the fibs, map it and then initialise the
123 * fib area, the unmapped fib data and also the free list
126 int aac_fib_setup(struct aac_dev
* dev
)
129 struct hw_fib
*hw_fib
;
130 dma_addr_t hw_fib_pa
;
133 while (((i
= fib_map_alloc(dev
)) == -ENOMEM
)
134 && (dev
->scsi_host_ptr
->can_queue
> (64 - AAC_NUM_MGT_FIB
))) {
135 dev
->init
->MaxIoCommands
= cpu_to_le32((dev
->scsi_host_ptr
->can_queue
+ AAC_NUM_MGT_FIB
) >> 1);
136 dev
->scsi_host_ptr
->can_queue
= le32_to_cpu(dev
->init
->MaxIoCommands
) - AAC_NUM_MGT_FIB
;
141 /* 32 byte alignment for PMC */
142 hw_fib_pa
= (dev
->hw_fib_pa
+ (ALIGN32
- 1)) & ~(ALIGN32
- 1);
143 dev
->hw_fib_va
= (struct hw_fib
*)((unsigned char *)dev
->hw_fib_va
+
144 (hw_fib_pa
- dev
->hw_fib_pa
));
145 dev
->hw_fib_pa
= hw_fib_pa
;
146 memset(dev
->hw_fib_va
, 0,
147 (dev
->max_fib_size
+ sizeof(struct aac_fib_xporthdr
)) *
148 (dev
->scsi_host_ptr
->can_queue
+ AAC_NUM_MGT_FIB
));
150 /* add Xport header */
151 dev
->hw_fib_va
= (struct hw_fib
*)((unsigned char *)dev
->hw_fib_va
+
152 sizeof(struct aac_fib_xporthdr
));
153 dev
->hw_fib_pa
+= sizeof(struct aac_fib_xporthdr
);
155 hw_fib
= dev
->hw_fib_va
;
156 hw_fib_pa
= dev
->hw_fib_pa
;
158 * Initialise the fibs
160 for (i
= 0, fibptr
= &dev
->fibs
[i
];
161 i
< (dev
->scsi_host_ptr
->can_queue
+ AAC_NUM_MGT_FIB
);
165 fibptr
->size
= sizeof(struct fib
);
167 fibptr
->hw_fib_va
= hw_fib
;
168 fibptr
->data
= (void *) fibptr
->hw_fib_va
->data
;
169 fibptr
->next
= fibptr
+1; /* Forward chain the fibs */
170 sema_init(&fibptr
->event_wait
, 0);
171 spin_lock_init(&fibptr
->event_lock
);
172 hw_fib
->header
.XferState
= cpu_to_le32(0xffffffff);
173 hw_fib
->header
.SenderSize
= cpu_to_le16(dev
->max_fib_size
);
174 fibptr
->hw_fib_pa
= hw_fib_pa
;
175 hw_fib
= (struct hw_fib
*)((unsigned char *)hw_fib
+
176 dev
->max_fib_size
+ sizeof(struct aac_fib_xporthdr
));
177 hw_fib_pa
= hw_fib_pa
+
178 dev
->max_fib_size
+ sizeof(struct aac_fib_xporthdr
);
182 *Assign vector numbers to fibs
184 aac_fib_vector_assign(dev
);
187 * Add the fib chain to the free list
189 dev
->fibs
[dev
->scsi_host_ptr
->can_queue
+ AAC_NUM_MGT_FIB
- 1].next
= NULL
;
191 * Set 8 fibs aside for management tools
193 dev
->free_fib
= &dev
->fibs
[dev
->scsi_host_ptr
->can_queue
];
198 * aac_fib_alloc_tag-allocate a fib using tags
199 * @dev: Adapter to allocate the fib for
201 * Allocate a fib from the adapter fib pool using tags
202 * from the blk layer.
205 struct fib
*aac_fib_alloc_tag(struct aac_dev
*dev
, struct scsi_cmnd
*scmd
)
209 fibptr
= &dev
->fibs
[scmd
->request
->tag
];
211 * Null out fields that depend on being zero at the start of
214 fibptr
->hw_fib_va
->header
.XferState
= 0;
215 fibptr
->type
= FSAFS_NTC_FIB_CONTEXT
;
216 fibptr
->callback_data
= NULL
;
217 fibptr
->callback
= NULL
;
223 * aac_fib_alloc - allocate a fib
224 * @dev: Adapter to allocate the fib for
226 * Allocate a fib from the adapter fib pool. If the pool is empty we
230 struct fib
*aac_fib_alloc(struct aac_dev
*dev
)
234 spin_lock_irqsave(&dev
->fib_lock
, flags
);
235 fibptr
= dev
->free_fib
;
237 spin_unlock_irqrestore(&dev
->fib_lock
, flags
);
240 dev
->free_fib
= fibptr
->next
;
241 spin_unlock_irqrestore(&dev
->fib_lock
, flags
);
243 * Set the proper node type code and node byte size
245 fibptr
->type
= FSAFS_NTC_FIB_CONTEXT
;
246 fibptr
->size
= sizeof(struct fib
);
248 * Null out fields that depend on being zero at the start of
251 fibptr
->hw_fib_va
->header
.XferState
= 0;
253 fibptr
->callback
= NULL
;
254 fibptr
->callback_data
= NULL
;
260 * aac_fib_free - free a fib
261 * @fibptr: fib to free up
263 * Frees up a fib and places it on the appropriate queue
266 void aac_fib_free(struct fib
*fibptr
)
270 if (fibptr
->done
== 2)
273 spin_lock_irqsave(&fibptr
->dev
->fib_lock
, flags
);
274 if (unlikely(fibptr
->flags
& FIB_CONTEXT_FLAG_TIMED_OUT
))
275 aac_config
.fib_timeouts
++;
276 if (fibptr
->hw_fib_va
->header
.XferState
!= 0) {
277 printk(KERN_WARNING
"aac_fib_free, XferState != 0, fibptr = 0x%p, XferState = 0x%x\n",
279 le32_to_cpu(fibptr
->hw_fib_va
->header
.XferState
));
281 fibptr
->next
= fibptr
->dev
->free_fib
;
282 fibptr
->dev
->free_fib
= fibptr
;
283 spin_unlock_irqrestore(&fibptr
->dev
->fib_lock
, flags
);
287 * aac_fib_init - initialise a fib
288 * @fibptr: The fib to initialize
290 * Set up the generic fib fields ready for use
293 void aac_fib_init(struct fib
*fibptr
)
295 struct hw_fib
*hw_fib
= fibptr
->hw_fib_va
;
297 memset(&hw_fib
->header
, 0, sizeof(struct aac_fibhdr
));
298 hw_fib
->header
.StructType
= FIB_MAGIC
;
299 hw_fib
->header
.Size
= cpu_to_le16(fibptr
->dev
->max_fib_size
);
300 hw_fib
->header
.XferState
= cpu_to_le32(HostOwned
| FibInitialized
| FibEmpty
| FastResponseCapable
);
301 hw_fib
->header
.u
.ReceiverFibAddress
= cpu_to_le32(fibptr
->hw_fib_pa
);
302 hw_fib
->header
.SenderSize
= cpu_to_le16(fibptr
->dev
->max_fib_size
);
306 * fib_deallocate - deallocate a fib
307 * @fibptr: fib to deallocate
309 * Will deallocate and return to the free pool the FIB pointed to by the
313 static void fib_dealloc(struct fib
* fibptr
)
315 struct hw_fib
*hw_fib
= fibptr
->hw_fib_va
;
316 hw_fib
->header
.XferState
= 0;
320 * Commuication primitives define and support the queuing method we use to
321 * support host to adapter commuication. All queue accesses happen through
322 * these routines and are the only routines which have a knowledge of the
323 * how these queues are implemented.
327 * aac_get_entry - get a queue entry
330 * @entry: Entry return
331 * @index: Index return
332 * @nonotify: notification control
334 * With a priority the routine returns a queue entry if the queue has free entries. If the queue
335 * is full(no free entries) than no entry is returned and the function returns 0 otherwise 1 is
339 static int aac_get_entry (struct aac_dev
* dev
, u32 qid
, struct aac_entry
**entry
, u32
* index
, unsigned long *nonotify
)
341 struct aac_queue
* q
;
345 * All of the queues wrap when they reach the end, so we check
346 * to see if they have reached the end and if they have we just
347 * set the index back to zero. This is a wrap. You could or off
348 * the high bits in all updates but this is a bit faster I think.
351 q
= &dev
->queues
->queue
[qid
];
353 idx
= *index
= le32_to_cpu(*(q
->headers
.producer
));
354 /* Interrupt Moderation, only interrupt for first two entries */
355 if (idx
!= le32_to_cpu(*(q
->headers
.consumer
))) {
357 if (qid
== AdapNormCmdQueue
)
358 idx
= ADAP_NORM_CMD_ENTRIES
;
360 idx
= ADAP_NORM_RESP_ENTRIES
;
362 if (idx
!= le32_to_cpu(*(q
->headers
.consumer
)))
366 if (qid
== AdapNormCmdQueue
) {
367 if (*index
>= ADAP_NORM_CMD_ENTRIES
)
368 *index
= 0; /* Wrap to front of the Producer Queue. */
370 if (*index
>= ADAP_NORM_RESP_ENTRIES
)
371 *index
= 0; /* Wrap to front of the Producer Queue. */
375 if ((*index
+ 1) == le32_to_cpu(*(q
->headers
.consumer
))) {
376 printk(KERN_WARNING
"Queue %d full, %u outstanding.\n",
377 qid
, atomic_read(&q
->numpending
));
380 *entry
= q
->base
+ *index
;
386 * aac_queue_get - get the next free QE
388 * @index: Returned index
389 * @priority: Priority of fib
390 * @fib: Fib to associate with the queue entry
391 * @wait: Wait if queue full
392 * @fibptr: Driver fib object to go with fib
393 * @nonotify: Don't notify the adapter
395 * Gets the next free QE off the requested priorty adapter command
396 * queue and associates the Fib with the QE. The QE represented by
397 * index is ready to insert on the queue when this routine returns
401 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
)
403 struct aac_entry
* entry
= NULL
;
406 if (qid
== AdapNormCmdQueue
) {
407 /* if no entries wait for some if caller wants to */
408 while (!aac_get_entry(dev
, qid
, &entry
, index
, nonotify
)) {
409 printk(KERN_ERR
"GetEntries failed\n");
412 * Setup queue entry with a command, status and fib mapped
414 entry
->size
= cpu_to_le32(le16_to_cpu(hw_fib
->header
.Size
));
417 while (!aac_get_entry(dev
, qid
, &entry
, index
, nonotify
)) {
418 /* if no entries wait for some if caller wants to */
421 * Setup queue entry with command, status and fib mapped
423 entry
->size
= cpu_to_le32(le16_to_cpu(hw_fib
->header
.Size
));
424 entry
->addr
= hw_fib
->header
.SenderFibAddress
;
425 /* Restore adapters pointer to the FIB */
426 hw_fib
->header
.u
.ReceiverFibAddress
= hw_fib
->header
.SenderFibAddress
; /* Let the adapter now where to find its data */
430 * If MapFib is true than we need to map the Fib and put pointers
431 * in the queue entry.
434 entry
->addr
= cpu_to_le32(fibptr
->hw_fib_pa
);
439 * Define the highest level of host to adapter communication routines.
440 * These routines will support host to adapter FS commuication. These
441 * routines have no knowledge of the commuication method used. This level
442 * sends and receives FIBs. This level has no knowledge of how these FIBs
443 * get passed back and forth.
447 * aac_fib_send - send a fib to the adapter
448 * @command: Command to send
450 * @size: Size of fib data area
451 * @priority: Priority of Fib
452 * @wait: Async/sync select
453 * @reply: True if a reply is wanted
454 * @callback: Called with reply
455 * @callback_data: Passed to callback
457 * Sends the requested FIB to the adapter and optionally will wait for a
458 * response FIB. If the caller does not wish to wait for a response than
459 * an event to wait on must be supplied. This event will be set when a
460 * response FIB is received from the adapter.
463 int aac_fib_send(u16 command
, struct fib
*fibptr
, unsigned long size
,
464 int priority
, int wait
, int reply
, fib_callback callback
,
467 struct aac_dev
* dev
= fibptr
->dev
;
468 struct hw_fib
* hw_fib
= fibptr
->hw_fib_va
;
469 unsigned long flags
= 0;
470 unsigned long mflags
= 0;
471 unsigned long sflags
= 0;
474 if (!(hw_fib
->header
.XferState
& cpu_to_le32(HostOwned
)))
477 * There are 5 cases with the wait and response requested flags.
478 * The only invalid cases are if the caller requests to wait and
479 * does not request a response and if the caller does not want a
480 * response and the Fib is not allocated from pool. If a response
481 * is not requesed the Fib will just be deallocaed by the DPC
482 * routine when the response comes back from the adapter. No
483 * further processing will be done besides deleting the Fib. We
484 * will have a debug mode where the adapter can notify the host
485 * it had a problem and the host can log that fact.
488 if (wait
&& !reply
) {
490 } else if (!wait
&& reply
) {
491 hw_fib
->header
.XferState
|= cpu_to_le32(Async
| ResponseExpected
);
492 FIB_COUNTER_INCREMENT(aac_config
.AsyncSent
);
493 } else if (!wait
&& !reply
) {
494 hw_fib
->header
.XferState
|= cpu_to_le32(NoResponseExpected
);
495 FIB_COUNTER_INCREMENT(aac_config
.NoResponseSent
);
496 } else if (wait
&& reply
) {
497 hw_fib
->header
.XferState
|= cpu_to_le32(ResponseExpected
);
498 FIB_COUNTER_INCREMENT(aac_config
.NormalSent
);
501 * Map the fib into 32bits by using the fib number
504 hw_fib
->header
.SenderFibAddress
= cpu_to_le32(((u32
)(fibptr
- dev
->fibs
)) << 2);
505 hw_fib
->header
.Handle
= (u32
)(fibptr
- dev
->fibs
) + 1;
507 * Set FIB state to indicate where it came from and if we want a
508 * response from the adapter. Also load the command from the
511 * Map the hw fib pointer as a 32bit value
513 hw_fib
->header
.Command
= cpu_to_le16(command
);
514 hw_fib
->header
.XferState
|= cpu_to_le32(SentFromHost
);
516 * Set the size of the Fib we want to send to the adapter
518 hw_fib
->header
.Size
= cpu_to_le16(sizeof(struct aac_fibhdr
) + size
);
519 if (le16_to_cpu(hw_fib
->header
.Size
) > le16_to_cpu(hw_fib
->header
.SenderSize
)) {
523 * Get a queue entry connect the FIB to it and send an notify
524 * the adapter a command is ready.
526 hw_fib
->header
.XferState
|= cpu_to_le32(NormalPriority
);
529 * Fill in the Callback and CallbackContext if we are not
533 fibptr
->callback
= callback
;
534 fibptr
->callback_data
= callback_data
;
535 fibptr
->flags
= FIB_CONTEXT_FLAG
;
540 FIB_COUNTER_INCREMENT(aac_config
.FibsSent
);
542 dprintk((KERN_DEBUG
"Fib contents:.\n"));
543 dprintk((KERN_DEBUG
" Command = %d.\n", le32_to_cpu(hw_fib
->header
.Command
)));
544 dprintk((KERN_DEBUG
" SubCommand = %d.\n", le32_to_cpu(((struct aac_query_mount
*)fib_data(fibptr
))->command
)));
545 dprintk((KERN_DEBUG
" XferState = %x.\n", le32_to_cpu(hw_fib
->header
.XferState
)));
546 dprintk((KERN_DEBUG
" hw_fib va being sent=%p\n",fibptr
->hw_fib_va
));
547 dprintk((KERN_DEBUG
" hw_fib pa being sent=%lx\n",(ulong
)fibptr
->hw_fib_pa
));
548 dprintk((KERN_DEBUG
" fib being sent=%p\n",fibptr
));
555 spin_lock_irqsave(&dev
->manage_lock
, mflags
);
556 if (dev
->management_fib_count
>= AAC_NUM_MGT_FIB
) {
557 printk(KERN_INFO
"No management Fibs Available:%d\n",
558 dev
->management_fib_count
);
559 spin_unlock_irqrestore(&dev
->manage_lock
, mflags
);
562 dev
->management_fib_count
++;
563 spin_unlock_irqrestore(&dev
->manage_lock
, mflags
);
564 spin_lock_irqsave(&fibptr
->event_lock
, flags
);
567 if (dev
->sync_mode
) {
569 spin_unlock_irqrestore(&fibptr
->event_lock
, flags
);
570 spin_lock_irqsave(&dev
->sync_lock
, sflags
);
572 list_add_tail(&fibptr
->fiblink
, &dev
->sync_fib_list
);
573 spin_unlock_irqrestore(&dev
->sync_lock
, sflags
);
575 dev
->sync_fib
= fibptr
;
576 spin_unlock_irqrestore(&dev
->sync_lock
, sflags
);
577 aac_adapter_sync_cmd(dev
, SEND_SYNCHRONOUS_FIB
,
578 (u32
)fibptr
->hw_fib_pa
, 0, 0, 0, 0, 0,
579 NULL
, NULL
, NULL
, NULL
, NULL
);
582 fibptr
->flags
|= FIB_CONTEXT_FLAG_WAIT
;
583 if (down_interruptible(&fibptr
->event_wait
)) {
584 fibptr
->flags
&= ~FIB_CONTEXT_FLAG_WAIT
;
592 if (aac_adapter_deliver(fibptr
) != 0) {
593 printk(KERN_ERR
"aac_fib_send: returned -EBUSY\n");
595 spin_unlock_irqrestore(&fibptr
->event_lock
, flags
);
596 spin_lock_irqsave(&dev
->manage_lock
, mflags
);
597 dev
->management_fib_count
--;
598 spin_unlock_irqrestore(&dev
->manage_lock
, mflags
);
605 * If the caller wanted us to wait for response wait now.
609 spin_unlock_irqrestore(&fibptr
->event_lock
, flags
);
610 /* Only set for first known interruptable command */
613 * *VERY* Dangerous to time out a command, the
614 * assumption is made that we have no hope of
615 * functioning because an interrupt routing or other
616 * hardware failure has occurred.
618 unsigned long timeout
= jiffies
+ (180 * HZ
); /* 3 minutes */
619 while (down_trylock(&fibptr
->event_wait
)) {
621 if (time_is_before_eq_jiffies(timeout
)) {
622 struct aac_queue
* q
= &dev
->queues
->queue
[AdapNormCmdQueue
];
623 atomic_dec(&q
->numpending
);
625 printk(KERN_ERR
"aacraid: aac_fib_send: first asynchronous command timed out.\n"
626 "Usually a result of a PCI interrupt routing problem;\n"
627 "update mother board BIOS or consider utilizing one of\n"
628 "the SAFE mode kernel options (acpi, apic etc)\n");
632 if ((blink
= aac_adapter_check_health(dev
)) > 0) {
634 printk(KERN_ERR
"aacraid: aac_fib_send: adapter blinkLED 0x%x.\n"
635 "Usually a result of a serious unrecoverable hardware problem\n",
641 * Allow other processes / CPUS to use core
645 } else if (down_interruptible(&fibptr
->event_wait
)) {
646 /* Do nothing ... satisfy
647 * down_interruptible must_check */
650 spin_lock_irqsave(&fibptr
->event_lock
, flags
);
651 if (fibptr
->done
== 0) {
652 fibptr
->done
= 2; /* Tell interrupt we aborted */
653 spin_unlock_irqrestore(&fibptr
->event_lock
, flags
);
656 spin_unlock_irqrestore(&fibptr
->event_lock
, flags
);
657 BUG_ON(fibptr
->done
== 0);
659 if(unlikely(fibptr
->flags
& FIB_CONTEXT_FLAG_TIMED_OUT
))
664 * If the user does not want a response than return success otherwise
674 * aac_consumer_get - get the top of the queue
677 * @entry: Return entry
679 * Will return a pointer to the entry on the top of the queue requested that
680 * we are a consumer of, and return the address of the queue entry. It does
681 * not change the state of the queue.
684 int aac_consumer_get(struct aac_dev
* dev
, struct aac_queue
* q
, struct aac_entry
**entry
)
688 if (le32_to_cpu(*q
->headers
.producer
) == le32_to_cpu(*q
->headers
.consumer
)) {
692 * The consumer index must be wrapped if we have reached
693 * the end of the queue, else we just use the entry
694 * pointed to by the header index
696 if (le32_to_cpu(*q
->headers
.consumer
) >= q
->entries
)
699 index
= le32_to_cpu(*q
->headers
.consumer
);
700 *entry
= q
->base
+ index
;
707 * aac_consumer_free - free consumer entry
712 * Frees up the current top of the queue we are a consumer of. If the
713 * queue was full notify the producer that the queue is no longer full.
716 void aac_consumer_free(struct aac_dev
* dev
, struct aac_queue
*q
, u32 qid
)
721 if ((le32_to_cpu(*q
->headers
.producer
)+1) == le32_to_cpu(*q
->headers
.consumer
))
724 if (le32_to_cpu(*q
->headers
.consumer
) >= q
->entries
)
725 *q
->headers
.consumer
= cpu_to_le32(1);
727 le32_add_cpu(q
->headers
.consumer
, 1);
732 case HostNormCmdQueue
:
733 notify
= HostNormCmdNotFull
;
735 case HostNormRespQueue
:
736 notify
= HostNormRespNotFull
;
742 aac_adapter_notify(dev
, notify
);
747 * aac_fib_adapter_complete - complete adapter issued fib
748 * @fibptr: fib to complete
751 * Will do all necessary work to complete a FIB that was sent from
755 int aac_fib_adapter_complete(struct fib
*fibptr
, unsigned short size
)
757 struct hw_fib
* hw_fib
= fibptr
->hw_fib_va
;
758 struct aac_dev
* dev
= fibptr
->dev
;
759 struct aac_queue
* q
;
760 unsigned long nointr
= 0;
761 unsigned long qflags
;
763 if (dev
->comm_interface
== AAC_COMM_MESSAGE_TYPE1
||
764 dev
->comm_interface
== AAC_COMM_MESSAGE_TYPE2
) {
769 if (hw_fib
->header
.XferState
== 0) {
770 if (dev
->comm_interface
== AAC_COMM_MESSAGE
)
775 * If we plan to do anything check the structure type first.
777 if (hw_fib
->header
.StructType
!= FIB_MAGIC
&&
778 hw_fib
->header
.StructType
!= FIB_MAGIC2
&&
779 hw_fib
->header
.StructType
!= FIB_MAGIC2_64
) {
780 if (dev
->comm_interface
== AAC_COMM_MESSAGE
)
785 * This block handles the case where the adapter had sent us a
786 * command and we have finished processing the command. We
787 * call completeFib when we are done processing the command
788 * and want to send a response back to the adapter. This will
789 * send the completed cdb to the adapter.
791 if (hw_fib
->header
.XferState
& cpu_to_le32(SentFromAdapter
)) {
792 if (dev
->comm_interface
== AAC_COMM_MESSAGE
) {
796 hw_fib
->header
.XferState
|= cpu_to_le32(HostProcessed
);
798 size
+= sizeof(struct aac_fibhdr
);
799 if (size
> le16_to_cpu(hw_fib
->header
.SenderSize
))
801 hw_fib
->header
.Size
= cpu_to_le16(size
);
803 q
= &dev
->queues
->queue
[AdapNormRespQueue
];
804 spin_lock_irqsave(q
->lock
, qflags
);
805 aac_queue_get(dev
, &index
, AdapNormRespQueue
, hw_fib
, 1, NULL
, &nointr
);
806 *(q
->headers
.producer
) = cpu_to_le32(index
+ 1);
807 spin_unlock_irqrestore(q
->lock
, qflags
);
808 if (!(nointr
& (int)aac_config
.irq_mod
))
809 aac_adapter_notify(dev
, AdapNormRespQueue
);
812 printk(KERN_WARNING
"aac_fib_adapter_complete: "
813 "Unknown xferstate detected.\n");
820 * aac_fib_complete - fib completion handler
821 * @fib: FIB to complete
823 * Will do all necessary work to complete a FIB.
826 int aac_fib_complete(struct fib
*fibptr
)
828 struct hw_fib
* hw_fib
= fibptr
->hw_fib_va
;
831 * Check for a fib which has already been completed
834 if (hw_fib
->header
.XferState
== 0)
837 * If we plan to do anything check the structure type first.
840 if (hw_fib
->header
.StructType
!= FIB_MAGIC
&&
841 hw_fib
->header
.StructType
!= FIB_MAGIC2
&&
842 hw_fib
->header
.StructType
!= FIB_MAGIC2_64
)
845 * This block completes a cdb which orginated on the host and we
846 * just need to deallocate the cdb or reinit it. At this point the
847 * command is complete that we had sent to the adapter and this
848 * cdb could be reused.
851 if((hw_fib
->header
.XferState
& cpu_to_le32(SentFromHost
)) &&
852 (hw_fib
->header
.XferState
& cpu_to_le32(AdapterProcessed
)))
856 else if(hw_fib
->header
.XferState
& cpu_to_le32(SentFromHost
))
859 * This handles the case when the host has aborted the I/O
860 * to the adapter because the adapter is not responding
863 } else if(hw_fib
->header
.XferState
& cpu_to_le32(HostOwned
)) {
872 * aac_printf - handle printf from firmware
876 * Print a message passed to us by the controller firmware on the
880 void aac_printf(struct aac_dev
*dev
, u32 val
)
882 char *cp
= dev
->printfbuf
;
883 if (dev
->printf_enabled
)
885 int length
= val
& 0xffff;
886 int level
= (val
>> 16) & 0xffff;
889 * The size of the printfbuf is set in port.c
890 * There is no variable or define for it
896 if (level
== LOG_AAC_HIGH_ERROR
)
897 printk(KERN_WARNING
"%s:%s", dev
->name
, cp
);
899 printk(KERN_INFO
"%s:%s", dev
->name
, cp
);
904 static inline int aac_aif_data(struct aac_aifcmd
*aifcmd
, uint32_t index
)
906 return le32_to_cpu(((__le32
*)aifcmd
->data
)[index
]);
910 static void aac_handle_aif_bu(struct aac_dev
*dev
, struct aac_aifcmd
*aifcmd
)
912 switch (aac_aif_data(aifcmd
, 1)) {
913 case AifBuCacheDataLoss
:
914 if (aac_aif_data(aifcmd
, 2))
915 dev_info(&dev
->pdev
->dev
, "Backup unit had cache data loss - [%d]\n",
916 aac_aif_data(aifcmd
, 2));
918 dev_info(&dev
->pdev
->dev
, "Backup Unit had cache data loss\n");
920 case AifBuCacheDataRecover
:
921 if (aac_aif_data(aifcmd
, 2))
922 dev_info(&dev
->pdev
->dev
, "DDR cache data recovered successfully - [%d]\n",
923 aac_aif_data(aifcmd
, 2));
925 dev_info(&dev
->pdev
->dev
, "DDR cache data recovered successfully\n");
931 * aac_handle_aif - Handle a message from the firmware
932 * @dev: Which adapter this fib is from
933 * @fibptr: Pointer to fibptr from adapter
935 * This routine handles a driver notify fib from the adapter and
936 * dispatches it to the appropriate routine for handling.
939 #define AIF_SNIFF_TIMEOUT (500*HZ)
940 static void aac_handle_aif(struct aac_dev
* dev
, struct fib
* fibptr
)
942 struct hw_fib
* hw_fib
= fibptr
->hw_fib_va
;
943 struct aac_aifcmd
* aifcmd
= (struct aac_aifcmd
*)hw_fib
->data
;
944 u32 channel
, id
, lun
, container
;
945 struct scsi_device
*device
;
951 } device_config_needed
= NOTHING
;
953 /* Sniff for container changes */
955 if (!dev
|| !dev
->fsa_dev
)
957 container
= channel
= id
= lun
= (u32
)-1;
960 * We have set this up to try and minimize the number of
961 * re-configures that take place. As a result of this when
962 * certain AIF's come in we will set a flag waiting for another
963 * type of AIF before setting the re-config flag.
965 switch (le32_to_cpu(aifcmd
->command
)) {
966 case AifCmdDriverNotify
:
967 switch (le32_to_cpu(((__le32
*)aifcmd
->data
)[0])) {
968 case AifRawDeviceRemove
:
969 container
= le32_to_cpu(((__le32
*)aifcmd
->data
)[1]);
970 if ((container
>> 28)) {
974 channel
= (container
>> 24) & 0xF;
975 if (channel
>= dev
->maximum_num_channels
) {
979 id
= container
& 0xFFFF;
980 if (id
>= dev
->maximum_num_physicals
) {
984 lun
= (container
>> 16) & 0xFF;
986 channel
= aac_phys_to_logical(channel
);
987 device_config_needed
=
988 (((__le32
*)aifcmd
->data
)[0] ==
989 cpu_to_le32(AifRawDeviceRemove
)) ? DELETE
: ADD
;
991 if (device_config_needed
== ADD
) {
992 device
= scsi_device_lookup(
996 scsi_remove_device(device
);
997 scsi_device_put(device
);
1002 * Morph or Expand complete
1004 case AifDenMorphComplete
:
1005 case AifDenVolumeExtendComplete
:
1006 container
= le32_to_cpu(((__le32
*)aifcmd
->data
)[1]);
1007 if (container
>= dev
->maximum_num_containers
)
1011 * Find the scsi_device associated with the SCSI
1012 * address. Make sure we have the right array, and if
1013 * so set the flag to initiate a new re-config once we
1014 * see an AifEnConfigChange AIF come through.
1017 if ((dev
!= NULL
) && (dev
->scsi_host_ptr
!= NULL
)) {
1018 device
= scsi_device_lookup(dev
->scsi_host_ptr
,
1019 CONTAINER_TO_CHANNEL(container
),
1020 CONTAINER_TO_ID(container
),
1021 CONTAINER_TO_LUN(container
));
1023 dev
->fsa_dev
[container
].config_needed
= CHANGE
;
1024 dev
->fsa_dev
[container
].config_waiting_on
= AifEnConfigChange
;
1025 dev
->fsa_dev
[container
].config_waiting_stamp
= jiffies
;
1026 scsi_device_put(device
);
1032 * If we are waiting on something and this happens to be
1033 * that thing then set the re-configure flag.
1035 if (container
!= (u32
)-1) {
1036 if (container
>= dev
->maximum_num_containers
)
1038 if ((dev
->fsa_dev
[container
].config_waiting_on
==
1039 le32_to_cpu(*(__le32
*)aifcmd
->data
)) &&
1040 time_before(jiffies
, dev
->fsa_dev
[container
].config_waiting_stamp
+ AIF_SNIFF_TIMEOUT
))
1041 dev
->fsa_dev
[container
].config_waiting_on
= 0;
1042 } else for (container
= 0;
1043 container
< dev
->maximum_num_containers
; ++container
) {
1044 if ((dev
->fsa_dev
[container
].config_waiting_on
==
1045 le32_to_cpu(*(__le32
*)aifcmd
->data
)) &&
1046 time_before(jiffies
, dev
->fsa_dev
[container
].config_waiting_stamp
+ AIF_SNIFF_TIMEOUT
))
1047 dev
->fsa_dev
[container
].config_waiting_on
= 0;
1051 case AifCmdEventNotify
:
1052 switch (le32_to_cpu(((__le32
*)aifcmd
->data
)[0])) {
1053 case AifEnBatteryEvent
:
1054 dev
->cache_protected
=
1055 (((__le32
*)aifcmd
->data
)[1] == cpu_to_le32(3));
1060 case AifEnAddContainer
:
1061 container
= le32_to_cpu(((__le32
*)aifcmd
->data
)[1]);
1062 if (container
>= dev
->maximum_num_containers
)
1064 dev
->fsa_dev
[container
].config_needed
= ADD
;
1065 dev
->fsa_dev
[container
].config_waiting_on
=
1067 dev
->fsa_dev
[container
].config_waiting_stamp
= jiffies
;
1073 case AifEnDeleteContainer
:
1074 container
= le32_to_cpu(((__le32
*)aifcmd
->data
)[1]);
1075 if (container
>= dev
->maximum_num_containers
)
1077 dev
->fsa_dev
[container
].config_needed
= DELETE
;
1078 dev
->fsa_dev
[container
].config_waiting_on
=
1080 dev
->fsa_dev
[container
].config_waiting_stamp
= jiffies
;
1084 * Container change detected. If we currently are not
1085 * waiting on something else, setup to wait on a Config Change.
1087 case AifEnContainerChange
:
1088 container
= le32_to_cpu(((__le32
*)aifcmd
->data
)[1]);
1089 if (container
>= dev
->maximum_num_containers
)
1091 if (dev
->fsa_dev
[container
].config_waiting_on
&&
1092 time_before(jiffies
, dev
->fsa_dev
[container
].config_waiting_stamp
+ AIF_SNIFF_TIMEOUT
))
1094 dev
->fsa_dev
[container
].config_needed
= CHANGE
;
1095 dev
->fsa_dev
[container
].config_waiting_on
=
1097 dev
->fsa_dev
[container
].config_waiting_stamp
= jiffies
;
1100 case AifEnConfigChange
:
1104 case AifEnDeleteJBOD
:
1105 container
= le32_to_cpu(((__le32
*)aifcmd
->data
)[1]);
1106 if ((container
>> 28)) {
1107 container
= (u32
)-1;
1110 channel
= (container
>> 24) & 0xF;
1111 if (channel
>= dev
->maximum_num_channels
) {
1112 container
= (u32
)-1;
1115 id
= container
& 0xFFFF;
1116 if (id
>= dev
->maximum_num_physicals
) {
1117 container
= (u32
)-1;
1120 lun
= (container
>> 16) & 0xFF;
1121 container
= (u32
)-1;
1122 channel
= aac_phys_to_logical(channel
);
1123 device_config_needed
=
1124 (((__le32
*)aifcmd
->data
)[0] ==
1125 cpu_to_le32(AifEnAddJBOD
)) ? ADD
: DELETE
;
1126 if (device_config_needed
== ADD
) {
1127 device
= scsi_device_lookup(dev
->scsi_host_ptr
,
1132 scsi_remove_device(device
);
1133 scsi_device_put(device
);
1138 case AifEnEnclosureManagement
:
1140 * If in JBOD mode, automatic exposure of new
1141 * physical target to be suppressed until configured.
1145 switch (le32_to_cpu(((__le32
*)aifcmd
->data
)[3])) {
1146 case EM_DRIVE_INSERTION
:
1147 case EM_DRIVE_REMOVAL
:
1148 case EM_SES_DRIVE_INSERTION
:
1149 case EM_SES_DRIVE_REMOVAL
:
1150 container
= le32_to_cpu(
1151 ((__le32
*)aifcmd
->data
)[2]);
1152 if ((container
>> 28)) {
1153 container
= (u32
)-1;
1156 channel
= (container
>> 24) & 0xF;
1157 if (channel
>= dev
->maximum_num_channels
) {
1158 container
= (u32
)-1;
1161 id
= container
& 0xFFFF;
1162 lun
= (container
>> 16) & 0xFF;
1163 container
= (u32
)-1;
1164 if (id
>= dev
->maximum_num_physicals
) {
1165 /* legacy dev_t ? */
1166 if ((0x2000 <= id
) || lun
|| channel
||
1167 ((channel
= (id
>> 7) & 0x3F) >=
1168 dev
->maximum_num_channels
))
1170 lun
= (id
>> 4) & 7;
1173 channel
= aac_phys_to_logical(channel
);
1174 device_config_needed
=
1175 ((((__le32
*)aifcmd
->data
)[3]
1176 == cpu_to_le32(EM_DRIVE_INSERTION
)) ||
1177 (((__le32
*)aifcmd
->data
)[3]
1178 == cpu_to_le32(EM_SES_DRIVE_INSERTION
))) ?
1182 case AifBuManagerEvent
:
1183 aac_handle_aif_bu(dev
, aifcmd
);
1188 * If we are waiting on something and this happens to be
1189 * that thing then set the re-configure flag.
1191 if (container
!= (u32
)-1) {
1192 if (container
>= dev
->maximum_num_containers
)
1194 if ((dev
->fsa_dev
[container
].config_waiting_on
==
1195 le32_to_cpu(*(__le32
*)aifcmd
->data
)) &&
1196 time_before(jiffies
, dev
->fsa_dev
[container
].config_waiting_stamp
+ AIF_SNIFF_TIMEOUT
))
1197 dev
->fsa_dev
[container
].config_waiting_on
= 0;
1198 } else for (container
= 0;
1199 container
< dev
->maximum_num_containers
; ++container
) {
1200 if ((dev
->fsa_dev
[container
].config_waiting_on
==
1201 le32_to_cpu(*(__le32
*)aifcmd
->data
)) &&
1202 time_before(jiffies
, dev
->fsa_dev
[container
].config_waiting_stamp
+ AIF_SNIFF_TIMEOUT
))
1203 dev
->fsa_dev
[container
].config_waiting_on
= 0;
1207 case AifCmdJobProgress
:
1209 * These are job progress AIF's. When a Clear is being
1210 * done on a container it is initially created then hidden from
1211 * the OS. When the clear completes we don't get a config
1212 * change so we monitor the job status complete on a clear then
1213 * wait for a container change.
1216 if (((__le32
*)aifcmd
->data
)[1] == cpu_to_le32(AifJobCtrZero
) &&
1217 (((__le32
*)aifcmd
->data
)[6] == ((__le32
*)aifcmd
->data
)[5] ||
1218 ((__le32
*)aifcmd
->data
)[4] == cpu_to_le32(AifJobStsSuccess
))) {
1220 container
< dev
->maximum_num_containers
;
1223 * Stomp on all config sequencing for all
1226 dev
->fsa_dev
[container
].config_waiting_on
=
1227 AifEnContainerChange
;
1228 dev
->fsa_dev
[container
].config_needed
= ADD
;
1229 dev
->fsa_dev
[container
].config_waiting_stamp
=
1233 if (((__le32
*)aifcmd
->data
)[1] == cpu_to_le32(AifJobCtrZero
) &&
1234 ((__le32
*)aifcmd
->data
)[6] == 0 &&
1235 ((__le32
*)aifcmd
->data
)[4] == cpu_to_le32(AifJobStsRunning
)) {
1237 container
< dev
->maximum_num_containers
;
1240 * Stomp on all config sequencing for all
1243 dev
->fsa_dev
[container
].config_waiting_on
=
1244 AifEnContainerChange
;
1245 dev
->fsa_dev
[container
].config_needed
= DELETE
;
1246 dev
->fsa_dev
[container
].config_waiting_stamp
=
1255 if (device_config_needed
== NOTHING
)
1256 for (; container
< dev
->maximum_num_containers
; ++container
) {
1257 if ((dev
->fsa_dev
[container
].config_waiting_on
== 0) &&
1258 (dev
->fsa_dev
[container
].config_needed
!= NOTHING
) &&
1259 time_before(jiffies
, dev
->fsa_dev
[container
].config_waiting_stamp
+ AIF_SNIFF_TIMEOUT
)) {
1260 device_config_needed
=
1261 dev
->fsa_dev
[container
].config_needed
;
1262 dev
->fsa_dev
[container
].config_needed
= NOTHING
;
1263 channel
= CONTAINER_TO_CHANNEL(container
);
1264 id
= CONTAINER_TO_ID(container
);
1265 lun
= CONTAINER_TO_LUN(container
);
1269 if (device_config_needed
== NOTHING
)
1273 * If we decided that a re-configuration needs to be done,
1274 * schedule it here on the way out the door, please close the door
1279 * Find the scsi_device associated with the SCSI address,
1280 * and mark it as changed, invalidating the cache. This deals
1281 * with changes to existing device IDs.
1284 if (!dev
|| !dev
->scsi_host_ptr
)
1287 * force reload of disk info via aac_probe_container
1289 if ((channel
== CONTAINER_CHANNEL
) &&
1290 (device_config_needed
!= NOTHING
)) {
1291 if (dev
->fsa_dev
[container
].valid
== 1)
1292 dev
->fsa_dev
[container
].valid
= 2;
1293 aac_probe_container(dev
, container
);
1295 device
= scsi_device_lookup(dev
->scsi_host_ptr
, channel
, id
, lun
);
1297 switch (device_config_needed
) {
1299 #if (defined(AAC_DEBUG_INSTRUMENT_AIF_DELETE))
1300 scsi_remove_device(device
);
1302 if (scsi_device_online(device
)) {
1303 scsi_device_set_state(device
, SDEV_OFFLINE
);
1304 sdev_printk(KERN_INFO
, device
,
1305 "Device offlined - %s\n",
1306 (channel
== CONTAINER_CHANNEL
) ?
1308 "enclosure services event");
1313 if (!scsi_device_online(device
)) {
1314 sdev_printk(KERN_INFO
, device
,
1315 "Device online - %s\n",
1316 (channel
== CONTAINER_CHANNEL
) ?
1318 "enclosure services event");
1319 scsi_device_set_state(device
, SDEV_RUNNING
);
1323 if ((channel
== CONTAINER_CHANNEL
)
1324 && (!dev
->fsa_dev
[container
].valid
)) {
1325 #if (defined(AAC_DEBUG_INSTRUMENT_AIF_DELETE))
1326 scsi_remove_device(device
);
1328 if (!scsi_device_online(device
))
1330 scsi_device_set_state(device
, SDEV_OFFLINE
);
1331 sdev_printk(KERN_INFO
, device
,
1332 "Device offlined - %s\n",
1337 scsi_rescan_device(&device
->sdev_gendev
);
1342 scsi_device_put(device
);
1343 device_config_needed
= NOTHING
;
1345 if (device_config_needed
== ADD
)
1346 scsi_add_device(dev
->scsi_host_ptr
, channel
, id
, lun
);
1347 if (channel
== CONTAINER_CHANNEL
) {
1349 device_config_needed
= NOTHING
;
1354 static int _aac_reset_adapter(struct aac_dev
*aac
, int forced
)
1358 struct Scsi_Host
*host
;
1359 struct scsi_device
*dev
;
1360 struct scsi_cmnd
*command
;
1361 struct scsi_cmnd
*command_list
;
1366 * - host is locked, unless called by the aacraid thread.
1367 * (a matter of convenience, due to legacy issues surrounding
1368 * eh_host_adapter_reset).
1369 * - in_reset is asserted, so no new i/o is getting to the
1371 * - The card is dead, or will be very shortly ;-/ so no new
1372 * commands are completing in the interrupt service.
1374 host
= aac
->scsi_host_ptr
;
1375 scsi_block_requests(host
);
1376 aac_adapter_disable_int(aac
);
1377 if (aac
->thread
->pid
!= current
->pid
) {
1378 spin_unlock_irq(host
->host_lock
);
1379 kthread_stop(aac
->thread
);
1384 * If a positive health, means in a known DEAD PANIC
1385 * state and the adapter could be reset to `try again'.
1387 retval
= aac_adapter_restart(aac
, forced
? 0 : aac_adapter_check_health(aac
));
1393 * Loop through the fibs, close the synchronous FIBS
1395 for (retval
= 1, index
= 0; index
< (aac
->scsi_host_ptr
->can_queue
+ AAC_NUM_MGT_FIB
); index
++) {
1396 struct fib
*fib
= &aac
->fibs
[index
];
1397 if (!(fib
->hw_fib_va
->header
.XferState
& cpu_to_le32(NoResponseExpected
| Async
)) &&
1398 (fib
->hw_fib_va
->header
.XferState
& cpu_to_le32(ResponseExpected
))) {
1399 unsigned long flagv
;
1400 spin_lock_irqsave(&fib
->event_lock
, flagv
);
1401 up(&fib
->event_wait
);
1402 spin_unlock_irqrestore(&fib
->event_lock
, flagv
);
1407 /* Give some extra time for ioctls to complete. */
1410 index
= aac
->cardtype
;
1413 * Re-initialize the adapter, first free resources, then carefully
1414 * apply the initialization sequence to come back again. Only risk
1415 * is a change in Firmware dropping cache, it is assumed the caller
1416 * will ensure that i/o is queisced and the card is flushed in that
1419 aac_fib_map_free(aac
);
1420 pci_free_consistent(aac
->pdev
, aac
->comm_size
, aac
->comm_addr
, aac
->comm_phys
);
1421 aac
->comm_addr
= NULL
;
1426 kfree(aac
->fsa_dev
);
1427 aac
->fsa_dev
= NULL
;
1428 quirks
= aac_get_driver_ident(index
)->quirks
;
1429 if (quirks
& AAC_QUIRK_31BIT
) {
1430 if (((retval
= pci_set_dma_mask(aac
->pdev
, DMA_BIT_MASK(31)))) ||
1431 ((retval
= pci_set_consistent_dma_mask(aac
->pdev
, DMA_BIT_MASK(31)))))
1434 if (((retval
= pci_set_dma_mask(aac
->pdev
, DMA_BIT_MASK(32)))) ||
1435 ((retval
= pci_set_consistent_dma_mask(aac
->pdev
, DMA_BIT_MASK(32)))))
1438 if ((retval
= (*(aac_get_driver_ident(index
)->init
))(aac
)))
1440 if (quirks
& AAC_QUIRK_31BIT
)
1441 if ((retval
= pci_set_dma_mask(aac
->pdev
, DMA_BIT_MASK(32))))
1444 aac
->thread
= kthread_run(aac_command_thread
, aac
, "%s",
1446 if (IS_ERR(aac
->thread
)) {
1447 retval
= PTR_ERR(aac
->thread
);
1451 (void)aac_get_adapter_info(aac
);
1452 if ((quirks
& AAC_QUIRK_34SG
) && (host
->sg_tablesize
> 34)) {
1453 host
->sg_tablesize
= 34;
1454 host
->max_sectors
= (host
->sg_tablesize
* 8) + 112;
1456 if ((quirks
& AAC_QUIRK_17SG
) && (host
->sg_tablesize
> 17)) {
1457 host
->sg_tablesize
= 17;
1458 host
->max_sectors
= (host
->sg_tablesize
* 8) + 112;
1460 aac_get_config_status(aac
, 1);
1461 aac_get_containers(aac
);
1463 * This is where the assumption that the Adapter is quiesced
1466 command_list
= NULL
;
1467 __shost_for_each_device(dev
, host
) {
1468 unsigned long flags
;
1469 spin_lock_irqsave(&dev
->list_lock
, flags
);
1470 list_for_each_entry(command
, &dev
->cmd_list
, list
)
1471 if (command
->SCp
.phase
== AAC_OWNER_FIRMWARE
) {
1472 command
->SCp
.buffer
= (struct scatterlist
*)command_list
;
1473 command_list
= command
;
1475 spin_unlock_irqrestore(&dev
->list_lock
, flags
);
1477 while ((command
= command_list
)) {
1478 command_list
= (struct scsi_cmnd
*)command
->SCp
.buffer
;
1479 command
->SCp
.buffer
= NULL
;
1480 command
->result
= DID_OK
<< 16
1481 | COMMAND_COMPLETE
<< 8
1482 | SAM_STAT_TASK_SET_FULL
;
1483 command
->SCp
.phase
= AAC_OWNER_ERROR_HANDLER
;
1484 command
->scsi_done(command
);
1490 scsi_unblock_requests(host
);
1492 spin_lock_irq(host
->host_lock
);
1497 int aac_reset_adapter(struct aac_dev
* aac
, int forced
)
1499 unsigned long flagv
= 0;
1501 struct Scsi_Host
* host
;
1503 if (spin_trylock_irqsave(&aac
->fib_lock
, flagv
) == 0)
1506 if (aac
->in_reset
) {
1507 spin_unlock_irqrestore(&aac
->fib_lock
, flagv
);
1511 spin_unlock_irqrestore(&aac
->fib_lock
, flagv
);
1514 * Wait for all commands to complete to this specific
1515 * target (block maximum 60 seconds). Although not necessary,
1516 * it does make us a good storage citizen.
1518 host
= aac
->scsi_host_ptr
;
1519 scsi_block_requests(host
);
1520 if (forced
< 2) for (retval
= 60; retval
; --retval
) {
1521 struct scsi_device
* dev
;
1522 struct scsi_cmnd
* command
;
1525 __shost_for_each_device(dev
, host
) {
1526 spin_lock_irqsave(&dev
->list_lock
, flagv
);
1527 list_for_each_entry(command
, &dev
->cmd_list
, list
) {
1528 if (command
->SCp
.phase
== AAC_OWNER_FIRMWARE
) {
1533 spin_unlock_irqrestore(&dev
->list_lock
, flagv
);
1539 * We can exit If all the commands are complete
1546 /* Quiesce build, flush cache, write through mode */
1548 aac_send_shutdown(aac
);
1549 spin_lock_irqsave(host
->host_lock
, flagv
);
1550 retval
= _aac_reset_adapter(aac
, forced
? forced
: ((aac_check_reset
!= 0) && (aac_check_reset
!= 1)));
1551 spin_unlock_irqrestore(host
->host_lock
, flagv
);
1553 if ((forced
< 2) && (retval
== -ENODEV
)) {
1554 /* Unwind aac_send_shutdown() IOP_RESET unsupported/disabled */
1555 struct fib
* fibctx
= aac_fib_alloc(aac
);
1557 struct aac_pause
*cmd
;
1560 aac_fib_init(fibctx
);
1562 cmd
= (struct aac_pause
*) fib_data(fibctx
);
1564 cmd
->command
= cpu_to_le32(VM_ContainerConfig
);
1565 cmd
->type
= cpu_to_le32(CT_PAUSE_IO
);
1566 cmd
->timeout
= cpu_to_le32(1);
1567 cmd
->min
= cpu_to_le32(1);
1568 cmd
->noRescan
= cpu_to_le32(1);
1569 cmd
->count
= cpu_to_le32(0);
1571 status
= aac_fib_send(ContainerCommand
,
1573 sizeof(struct aac_pause
),
1575 -2 /* Timeout silently */, 1,
1579 aac_fib_complete(fibctx
);
1580 /* FIB should be freed only after getting
1581 * the response from the F/W */
1582 if (status
!= -ERESTARTSYS
)
1583 aac_fib_free(fibctx
);
1590 int aac_check_health(struct aac_dev
* aac
)
1593 unsigned long time_now
, flagv
= 0;
1594 struct list_head
* entry
;
1595 struct Scsi_Host
* host
;
1597 /* Extending the scope of fib_lock slightly to protect aac->in_reset */
1598 if (spin_trylock_irqsave(&aac
->fib_lock
, flagv
) == 0)
1601 if (aac
->in_reset
|| !(BlinkLED
= aac_adapter_check_health(aac
))) {
1602 spin_unlock_irqrestore(&aac
->fib_lock
, flagv
);
1609 * aac_aifcmd.command = AifCmdEventNotify = 1
1610 * aac_aifcmd.seqnum = 0xFFFFFFFF
1611 * aac_aifcmd.data[0] = AifEnExpEvent = 23
1612 * aac_aifcmd.data[1] = AifExeFirmwarePanic = 3
1613 * aac.aifcmd.data[2] = AifHighPriority = 3
1614 * aac.aifcmd.data[3] = BlinkLED
1617 time_now
= jiffies
/HZ
;
1618 entry
= aac
->fib_list
.next
;
1621 * For each Context that is on the
1622 * fibctxList, make a copy of the
1623 * fib, and then set the event to wake up the
1624 * thread that is waiting for it.
1626 while (entry
!= &aac
->fib_list
) {
1628 * Extract the fibctx
1630 struct aac_fib_context
*fibctx
= list_entry(entry
, struct aac_fib_context
, next
);
1631 struct hw_fib
* hw_fib
;
1634 * Check if the queue is getting
1637 if (fibctx
->count
> 20) {
1639 * It's *not* jiffies folks,
1640 * but jiffies / HZ, so do not
1643 u32 time_last
= fibctx
->jiffies
;
1645 * Has it been > 2 minutes
1646 * since the last read off
1649 if ((time_now
- time_last
) > aif_timeout
) {
1650 entry
= entry
->next
;
1651 aac_close_fib_context(aac
, fibctx
);
1656 * Warning: no sleep allowed while
1659 hw_fib
= kzalloc(sizeof(struct hw_fib
), GFP_ATOMIC
);
1660 fib
= kzalloc(sizeof(struct fib
), GFP_ATOMIC
);
1661 if (fib
&& hw_fib
) {
1662 struct aac_aifcmd
* aif
;
1664 fib
->hw_fib_va
= hw_fib
;
1667 fib
->type
= FSAFS_NTC_FIB_CONTEXT
;
1668 fib
->size
= sizeof (struct fib
);
1669 fib
->data
= hw_fib
->data
;
1670 aif
= (struct aac_aifcmd
*)hw_fib
->data
;
1671 aif
->command
= cpu_to_le32(AifCmdEventNotify
);
1672 aif
->seqnum
= cpu_to_le32(0xFFFFFFFF);
1673 ((__le32
*)aif
->data
)[0] = cpu_to_le32(AifEnExpEvent
);
1674 ((__le32
*)aif
->data
)[1] = cpu_to_le32(AifExeFirmwarePanic
);
1675 ((__le32
*)aif
->data
)[2] = cpu_to_le32(AifHighPriority
);
1676 ((__le32
*)aif
->data
)[3] = cpu_to_le32(BlinkLED
);
1679 * Put the FIB onto the
1682 list_add_tail(&fib
->fiblink
, &fibctx
->fib_list
);
1685 * Set the event to wake up the
1686 * thread that will waiting.
1688 up(&fibctx
->wait_sem
);
1690 printk(KERN_WARNING
"aifd: didn't allocate NewFib.\n");
1694 entry
= entry
->next
;
1697 spin_unlock_irqrestore(&aac
->fib_lock
, flagv
);
1700 printk(KERN_ERR
"%s: Host adapter dead %d\n", aac
->name
, BlinkLED
);
1704 printk(KERN_ERR
"%s: Host adapter BLINK LED 0x%x\n", aac
->name
, BlinkLED
);
1706 if (!aac_check_reset
|| ((aac_check_reset
== 1) &&
1707 (aac
->supplement_adapter_info
.SupportedOptions2
&
1708 AAC_OPTION_IGNORE_RESET
)))
1710 host
= aac
->scsi_host_ptr
;
1711 if (aac
->thread
->pid
!= current
->pid
)
1712 spin_lock_irqsave(host
->host_lock
, flagv
);
1713 BlinkLED
= _aac_reset_adapter(aac
, aac_check_reset
!= 1);
1714 if (aac
->thread
->pid
!= current
->pid
)
1715 spin_unlock_irqrestore(host
->host_lock
, flagv
);
1725 * aac_command_thread - command processing thread
1726 * @dev: Adapter to monitor
1728 * Waits on the commandready event in it's queue. When the event gets set
1729 * it will pull FIBs off it's queue. It will continue to pull FIBs off
1730 * until the queue is empty. When the queue is empty it will wait for
1734 int aac_command_thread(void *data
)
1736 struct aac_dev
*dev
= data
;
1737 struct hw_fib
*hw_fib
, *hw_newfib
;
1738 struct fib
*fib
, *newfib
;
1739 struct aac_fib_context
*fibctx
;
1740 unsigned long flags
;
1741 DECLARE_WAITQUEUE(wait
, current
);
1742 unsigned long next_jiffies
= jiffies
+ HZ
;
1743 unsigned long next_check_jiffies
= next_jiffies
;
1744 long difference
= HZ
;
1747 * We can only have one thread per adapter for AIF's.
1749 if (dev
->aif_thread
)
1753 * Let the DPC know it has a place to send the AIF's to.
1755 dev
->aif_thread
= 1;
1756 add_wait_queue(&dev
->queues
->queue
[HostNormCmdQueue
].cmdready
, &wait
);
1757 set_current_state(TASK_INTERRUPTIBLE
);
1758 dprintk ((KERN_INFO
"aac_command_thread start\n"));
1760 spin_lock_irqsave(dev
->queues
->queue
[HostNormCmdQueue
].lock
, flags
);
1761 while(!list_empty(&(dev
->queues
->queue
[HostNormCmdQueue
].cmdq
))) {
1762 struct list_head
*entry
;
1763 struct aac_aifcmd
* aifcmd
;
1765 set_current_state(TASK_RUNNING
);
1767 entry
= dev
->queues
->queue
[HostNormCmdQueue
].cmdq
.next
;
1770 spin_unlock_irqrestore(dev
->queues
->queue
[HostNormCmdQueue
].lock
, flags
);
1771 fib
= list_entry(entry
, struct fib
, fiblink
);
1773 * We will process the FIB here or pass it to a
1774 * worker thread that is TBD. We Really can't
1775 * do anything at this point since we don't have
1776 * anything defined for this thread to do.
1778 hw_fib
= fib
->hw_fib_va
;
1779 memset(fib
, 0, sizeof(struct fib
));
1780 fib
->type
= FSAFS_NTC_FIB_CONTEXT
;
1781 fib
->size
= sizeof(struct fib
);
1782 fib
->hw_fib_va
= hw_fib
;
1783 fib
->data
= hw_fib
->data
;
1786 * We only handle AifRequest fibs from the adapter.
1788 aifcmd
= (struct aac_aifcmd
*) hw_fib
->data
;
1789 if (aifcmd
->command
== cpu_to_le32(AifCmdDriverNotify
)) {
1790 /* Handle Driver Notify Events */
1791 aac_handle_aif(dev
, fib
);
1792 *(__le32
*)hw_fib
->data
= cpu_to_le32(ST_OK
);
1793 aac_fib_adapter_complete(fib
, (u16
)sizeof(u32
));
1795 /* The u32 here is important and intended. We are using
1796 32bit wrapping time to fit the adapter field */
1798 u32 time_now
, time_last
;
1799 unsigned long flagv
;
1801 struct hw_fib
** hw_fib_pool
, ** hw_fib_p
;
1802 struct fib
** fib_pool
, ** fib_p
;
1805 if ((aifcmd
->command
==
1806 cpu_to_le32(AifCmdEventNotify
)) ||
1808 cpu_to_le32(AifCmdJobProgress
))) {
1809 aac_handle_aif(dev
, fib
);
1812 time_now
= jiffies
/HZ
;
1815 * Warning: no sleep allowed while
1816 * holding spinlock. We take the estimate
1817 * and pre-allocate a set of fibs outside the
1820 num
= le32_to_cpu(dev
->init
->AdapterFibsSize
)
1821 / sizeof(struct hw_fib
); /* some extra */
1822 spin_lock_irqsave(&dev
->fib_lock
, flagv
);
1823 entry
= dev
->fib_list
.next
;
1824 while (entry
!= &dev
->fib_list
) {
1825 entry
= entry
->next
;
1828 spin_unlock_irqrestore(&dev
->fib_lock
, flagv
);
1832 && ((hw_fib_pool
= kmalloc(sizeof(struct hw_fib
*) * num
, GFP_KERNEL
)))
1833 && ((fib_pool
= kmalloc(sizeof(struct fib
*) * num
, GFP_KERNEL
)))) {
1834 hw_fib_p
= hw_fib_pool
;
1836 while (hw_fib_p
< &hw_fib_pool
[num
]) {
1837 if (!(*(hw_fib_p
++) = kmalloc(sizeof(struct hw_fib
), GFP_KERNEL
))) {
1841 if (!(*(fib_p
++) = kmalloc(sizeof(struct fib
), GFP_KERNEL
))) {
1842 kfree(*(--hw_fib_p
));
1846 if ((num
= hw_fib_p
- hw_fib_pool
) == 0) {
1856 spin_lock_irqsave(&dev
->fib_lock
, flagv
);
1857 entry
= dev
->fib_list
.next
;
1859 * For each Context that is on the
1860 * fibctxList, make a copy of the
1861 * fib, and then set the event to wake up the
1862 * thread that is waiting for it.
1864 hw_fib_p
= hw_fib_pool
;
1866 while (entry
!= &dev
->fib_list
) {
1868 * Extract the fibctx
1870 fibctx
= list_entry(entry
, struct aac_fib_context
, next
);
1872 * Check if the queue is getting
1875 if (fibctx
->count
> 20)
1878 * It's *not* jiffies folks,
1879 * but jiffies / HZ so do not
1882 time_last
= fibctx
->jiffies
;
1884 * Has it been > 2 minutes
1885 * since the last read off
1888 if ((time_now
- time_last
) > aif_timeout
) {
1889 entry
= entry
->next
;
1890 aac_close_fib_context(dev
, fibctx
);
1895 * Warning: no sleep allowed while
1898 if (hw_fib_p
< &hw_fib_pool
[num
]) {
1899 hw_newfib
= *hw_fib_p
;
1900 *(hw_fib_p
++) = NULL
;
1904 * Make the copy of the FIB
1906 memcpy(hw_newfib
, hw_fib
, sizeof(struct hw_fib
));
1907 memcpy(newfib
, fib
, sizeof(struct fib
));
1908 newfib
->hw_fib_va
= hw_newfib
;
1910 * Put the FIB onto the
1913 list_add_tail(&newfib
->fiblink
, &fibctx
->fib_list
);
1916 * Set the event to wake up the
1917 * thread that is waiting.
1919 up(&fibctx
->wait_sem
);
1921 printk(KERN_WARNING
"aifd: didn't allocate NewFib.\n");
1923 entry
= entry
->next
;
1926 * Set the status of this FIB
1928 *(__le32
*)hw_fib
->data
= cpu_to_le32(ST_OK
);
1929 aac_fib_adapter_complete(fib
, sizeof(u32
));
1930 spin_unlock_irqrestore(&dev
->fib_lock
, flagv
);
1931 /* Free up the remaining resources */
1932 hw_fib_p
= hw_fib_pool
;
1934 while (hw_fib_p
< &hw_fib_pool
[num
]) {
1944 spin_lock_irqsave(dev
->queues
->queue
[HostNormCmdQueue
].lock
, flags
);
1947 * There are no more AIF's
1949 spin_unlock_irqrestore(dev
->queues
->queue
[HostNormCmdQueue
].lock
, flags
);
1952 * Background activity
1954 if ((time_before(next_check_jiffies
,next_jiffies
))
1955 && ((difference
= next_check_jiffies
- jiffies
) <= 0)) {
1956 next_check_jiffies
= next_jiffies
;
1957 if (aac_check_health(dev
) == 0) {
1958 difference
= ((long)(unsigned)check_interval
)
1960 next_check_jiffies
= jiffies
+ difference
;
1961 } else if (!dev
->queues
)
1964 if (!time_before(next_check_jiffies
,next_jiffies
)
1965 && ((difference
= next_jiffies
- jiffies
) <= 0)) {
1969 /* Don't even try to talk to adapter if its sick */
1970 ret
= aac_check_health(dev
);
1971 if (!ret
&& !dev
->queues
)
1973 next_check_jiffies
= jiffies
1974 + ((long)(unsigned)check_interval
)
1976 do_gettimeofday(&now
);
1978 /* Synchronize our watches */
1979 if (((1000000 - (1000000 / HZ
)) > now
.tv_usec
)
1980 && (now
.tv_usec
> (1000000 / HZ
)))
1981 difference
= (((1000000 - now
.tv_usec
) * HZ
)
1982 + 500000) / 1000000;
1983 else if (ret
== 0) {
1986 if ((fibptr
= aac_fib_alloc(dev
))) {
1990 aac_fib_init(fibptr
);
1992 info
= (__le32
*) fib_data(fibptr
);
1993 if (now
.tv_usec
> 500000)
1996 *info
= cpu_to_le32(now
.tv_sec
);
1998 status
= aac_fib_send(SendHostTime
,
2005 /* Do not set XferState to zero unless
2006 * receives a response from F/W */
2008 aac_fib_complete(fibptr
);
2009 /* FIB should be freed only after
2010 * getting the response from the F/W */
2011 if (status
!= -ERESTARTSYS
)
2012 aac_fib_free(fibptr
);
2014 difference
= (long)(unsigned)update_interval
*HZ
;
2017 difference
= 10 * HZ
;
2019 next_jiffies
= jiffies
+ difference
;
2020 if (time_before(next_check_jiffies
,next_jiffies
))
2021 difference
= next_check_jiffies
- jiffies
;
2023 if (difference
<= 0)
2025 set_current_state(TASK_INTERRUPTIBLE
);
2027 if (kthread_should_stop())
2030 schedule_timeout(difference
);
2032 if (kthread_should_stop())
2036 remove_wait_queue(&dev
->queues
->queue
[HostNormCmdQueue
].cmdready
, &wait
);
2037 dev
->aif_thread
= 0;
2041 int aac_acquire_irq(struct aac_dev
*dev
)
2048 cpu
= cpumask_first(cpu_online_mask
);
2049 if (!dev
->sync_mode
&& dev
->msi_enabled
&& dev
->max_msix
> 1) {
2050 for (i
= 0; i
< dev
->max_msix
; i
++) {
2051 dev
->aac_msix
[i
].vector_no
= i
;
2052 dev
->aac_msix
[i
].dev
= dev
;
2053 if (request_irq(dev
->msixentry
[i
].vector
,
2054 dev
->a_ops
.adapter_intr
,
2055 0, "aacraid", &(dev
->aac_msix
[i
]))) {
2056 printk(KERN_ERR
"%s%d: Failed to register IRQ for vector %d.\n",
2057 dev
->name
, dev
->id
, i
);
2058 for (j
= 0 ; j
< i
; j
++)
2059 free_irq(dev
->msixentry
[j
].vector
,
2060 &(dev
->aac_msix
[j
]));
2061 pci_disable_msix(dev
->pdev
);
2064 if (irq_set_affinity_hint(dev
->msixentry
[i
].vector
,
2065 get_cpu_mask(cpu
))) {
2066 printk(KERN_ERR
"%s%d: Failed to set IRQ affinity for cpu %d\n",
2067 dev
->name
, dev
->id
, cpu
);
2069 cpu
= cpumask_next(cpu
, cpu_online_mask
);
2072 dev
->aac_msix
[0].vector_no
= 0;
2073 dev
->aac_msix
[0].dev
= dev
;
2075 if (request_irq(dev
->pdev
->irq
, dev
->a_ops
.adapter_intr
,
2076 IRQF_SHARED
, "aacraid",
2077 &(dev
->aac_msix
[0])) < 0) {
2079 pci_disable_msi(dev
->pdev
);
2080 printk(KERN_ERR
"%s%d: Interrupt unavailable.\n",
2081 dev
->name
, dev
->id
);
2088 void aac_free_irq(struct aac_dev
*dev
)
2093 cpu
= cpumask_first(cpu_online_mask
);
2094 if (dev
->pdev
->device
== PMC_DEVICE_S6
||
2095 dev
->pdev
->device
== PMC_DEVICE_S7
||
2096 dev
->pdev
->device
== PMC_DEVICE_S8
||
2097 dev
->pdev
->device
== PMC_DEVICE_S9
) {
2098 if (dev
->max_msix
> 1) {
2099 for (i
= 0; i
< dev
->max_msix
; i
++) {
2100 if (irq_set_affinity_hint(
2101 dev
->msixentry
[i
].vector
, NULL
)) {
2102 printk(KERN_ERR
"%s%d: Failed to reset IRQ affinity for cpu %d\n",
2103 dev
->name
, dev
->id
, cpu
);
2105 cpu
= cpumask_next(cpu
, cpu_online_mask
);
2106 free_irq(dev
->msixentry
[i
].vector
,
2107 &(dev
->aac_msix
[i
]));
2110 free_irq(dev
->pdev
->irq
, &(dev
->aac_msix
[0]));
2113 free_irq(dev
->pdev
->irq
, dev
);
2116 pci_disable_msi(dev
->pdev
);
2117 else if (dev
->max_msix
> 1)
2118 pci_disable_msix(dev
->pdev
);