blob: a23d7e5de5b086b527b9e637f88b3d8ca4436e85 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 *
Mark Haverkamp03d44332007-03-15 10:27:45 -07008 * Copyright (c) 2000-2007 Adaptec, Inc. (aacraid@adaptec.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
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
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -070028 * communication.
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 *
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>
Al Viro164006d2005-11-30 23:47:05 -050041#include <linux/delay.h>
Christoph Hellwigfe273812006-02-14 18:45:06 +010042#include <linux/kthread.h>
Al Viro6a3670c2006-09-24 23:45:29 +010043#include <linux/interrupt.h>
Mark Haverkamp8c867b22006-08-03 08:03:30 -070044#include <scsi/scsi.h>
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -070045#include <scsi/scsi_host.h>
Mark Haverkamp131256c2005-09-26 13:04:56 -070046#include <scsi/scsi_device.h>
Mark Haverkamp8c867b22006-08-03 08:03:30 -070047#include <scsi/scsi_cmnd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <asm/semaphore.h>
49
50#include "aacraid.h"
51
52/**
53 * fib_map_alloc - allocate the fib objects
54 * @dev: Adapter to allocate for
55 *
56 * Allocate and map the shared PCI space for the FIB blocks used to
57 * talk to the Adaptec firmware.
58 */
59
60static int fib_map_alloc(struct aac_dev *dev)
61{
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -070062 dprintk((KERN_INFO
63 "allocate hardware fibs pci_alloc_consistent(%p, %d * (%d + %d), %p)\n",
64 dev->pdev, dev->max_fib_size, dev->scsi_host_ptr->can_queue,
65 AAC_NUM_MGT_FIB, &dev->hw_fib_pa));
66 if((dev->hw_fib_va = pci_alloc_consistent(dev->pdev, dev->max_fib_size
67 * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB),
68 &dev->hw_fib_pa))==NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 return -ENOMEM;
70 return 0;
71}
72
73/**
Mark Haverkampbfb35aa82006-02-01 09:30:55 -080074 * aac_fib_map_free - free the fib objects
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 * @dev: Adapter to free
76 *
77 * Free the PCI mappings and the memory allocated for FIB blocks
78 * on this adapter.
79 */
80
Mark Haverkampbfb35aa82006-02-01 09:30:55 -080081void aac_fib_map_free(struct aac_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070082{
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -070083 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084}
85
86/**
Mark Haverkampbfb35aa82006-02-01 09:30:55 -080087 * aac_fib_setup - setup the fibs
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 * @dev: Adapter to set up
89 *
90 * Allocate the PCI space for the fibs, map it and then intialise the
91 * fib area, the unmapped fib data and also the free list
92 */
93
Mark Haverkampbfb35aa82006-02-01 09:30:55 -080094int aac_fib_setup(struct aac_dev * dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070095{
96 struct fib *fibptr;
Mark Haverkampa8166a52007-03-15 10:26:22 -070097 struct hw_fib *hw_fib;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 dma_addr_t hw_fib_pa;
99 int i;
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700100
101 while (((i = fib_map_alloc(dev)) == -ENOMEM)
102 && (dev->scsi_host_ptr->can_queue > (64 - AAC_NUM_MGT_FIB))) {
103 dev->init->MaxIoCommands = cpu_to_le32((dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB) >> 1);
104 dev->scsi_host_ptr->can_queue = le32_to_cpu(dev->init->MaxIoCommands) - AAC_NUM_MGT_FIB;
105 }
106 if (i<0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 return -ENOMEM;
108
Mark Haverkampa8166a52007-03-15 10:26:22 -0700109 hw_fib = dev->hw_fib_va;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 hw_fib_pa = dev->hw_fib_pa;
Mark Haverkampa8166a52007-03-15 10:26:22 -0700111 memset(hw_fib, 0, dev->max_fib_size * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 /*
113 * Initialise the fibs
114 */
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700115 for (i = 0, fibptr = &dev->fibs[i]; i < (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); i++, fibptr++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 {
117 fibptr->dev = dev;
Mark Haverkampa8166a52007-03-15 10:26:22 -0700118 fibptr->hw_fib_va = hw_fib;
119 fibptr->data = (void *) fibptr->hw_fib_va->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 fibptr->next = fibptr+1; /* Forward chain the fibs */
121 init_MUTEX_LOCKED(&fibptr->event_wait);
122 spin_lock_init(&fibptr->event_lock);
Mark Haverkampa8166a52007-03-15 10:26:22 -0700123 hw_fib->header.XferState = cpu_to_le32(0xffffffff);
124 hw_fib->header.SenderSize = cpu_to_le16(dev->max_fib_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 fibptr->hw_fib_pa = hw_fib_pa;
Mark Haverkampa8166a52007-03-15 10:26:22 -0700126 hw_fib = (struct hw_fib *)((unsigned char *)hw_fib + dev->max_fib_size);
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700127 hw_fib_pa = hw_fib_pa + dev->max_fib_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 }
129 /*
130 * Add the fib chain to the free list
131 */
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700132 dev->fibs[dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB - 1].next = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 /*
134 * Enable this to debug out of queue space
135 */
136 dev->free_fib = &dev->fibs[0];
137 return 0;
138}
139
140/**
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800141 * aac_fib_alloc - allocate a fib
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 * @dev: Adapter to allocate the fib for
143 *
144 * Allocate a fib from the adapter fib pool. If the pool is empty we
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700145 * return NULL.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 */
147
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800148struct fib *aac_fib_alloc(struct aac_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149{
150 struct fib * fibptr;
151 unsigned long flags;
152 spin_lock_irqsave(&dev->fib_lock, flags);
153 fibptr = dev->free_fib;
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700154 if(!fibptr){
155 spin_unlock_irqrestore(&dev->fib_lock, flags);
156 return fibptr;
157 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 dev->free_fib = fibptr->next;
159 spin_unlock_irqrestore(&dev->fib_lock, flags);
160 /*
161 * Set the proper node type code and node byte size
162 */
163 fibptr->type = FSAFS_NTC_FIB_CONTEXT;
164 fibptr->size = sizeof(struct fib);
165 /*
166 * Null out fields that depend on being zero at the start of
167 * each I/O
168 */
Mark Haverkampa8166a52007-03-15 10:26:22 -0700169 fibptr->hw_fib_va->header.XferState = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 fibptr->callback = NULL;
171 fibptr->callback_data = NULL;
172
173 return fibptr;
174}
175
176/**
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800177 * aac_fib_free - free a fib
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 * @fibptr: fib to free up
179 *
180 * Frees up a fib and places it on the appropriate queue
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 */
182
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800183void aac_fib_free(struct fib *fibptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184{
185 unsigned long flags;
186
187 spin_lock_irqsave(&fibptr->dev->fib_lock, flags);
Mark Haverkamp03d44332007-03-15 10:27:45 -0700188 if (unlikely(fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 aac_config.fib_timeouts++;
Mark Haverkamp03d44332007-03-15 10:27:45 -0700190 if (fibptr->hw_fib_va->header.XferState != 0) {
191 printk(KERN_WARNING "aac_fib_free, XferState != 0, fibptr = 0x%p, XferState = 0x%x\n",
192 (void*)fibptr,
193 le32_to_cpu(fibptr->hw_fib_va->header.XferState));
194 }
195 fibptr->next = fibptr->dev->free_fib;
196 fibptr->dev->free_fib = fibptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 spin_unlock_irqrestore(&fibptr->dev->fib_lock, flags);
198}
199
200/**
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800201 * aac_fib_init - initialise a fib
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 * @fibptr: The fib to initialize
203 *
204 * Set up the generic fib fields ready for use
205 */
206
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800207void aac_fib_init(struct fib *fibptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208{
Mark Haverkampa8166a52007-03-15 10:26:22 -0700209 struct hw_fib *hw_fib = fibptr->hw_fib_va;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
211 hw_fib->header.StructType = FIB_MAGIC;
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700212 hw_fib->header.Size = cpu_to_le16(fibptr->dev->max_fib_size);
213 hw_fib->header.XferState = cpu_to_le32(HostOwned | FibInitialized | FibEmpty | FastResponseCapable);
Mark Haverkamp8e0c5eb2005-10-24 10:52:22 -0700214 hw_fib->header.SenderFibAddress = 0; /* Filled in later if needed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 hw_fib->header.ReceiverFibAddress = cpu_to_le32(fibptr->hw_fib_pa);
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700216 hw_fib->header.SenderSize = cpu_to_le16(fibptr->dev->max_fib_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217}
218
219/**
220 * fib_deallocate - deallocate a fib
221 * @fibptr: fib to deallocate
222 *
223 * Will deallocate and return to the free pool the FIB pointed to by the
224 * caller.
225 */
226
Adrian Bunk 48338692005-04-25 19:45:58 -0700227static void fib_dealloc(struct fib * fibptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228{
Mark Haverkampa8166a52007-03-15 10:26:22 -0700229 struct hw_fib *hw_fib = fibptr->hw_fib_va;
Eric Sesterhenn125e1872006-06-23 02:06:06 -0700230 BUG_ON(hw_fib->header.StructType != FIB_MAGIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 hw_fib->header.XferState = 0;
232}
233
234/*
235 * Commuication primitives define and support the queuing method we use to
236 * support host to adapter commuication. All queue accesses happen through
237 * these routines and are the only routines which have a knowledge of the
238 * how these queues are implemented.
239 */
240
241/**
242 * aac_get_entry - get a queue entry
243 * @dev: Adapter
244 * @qid: Queue Number
245 * @entry: Entry return
246 * @index: Index return
247 * @nonotify: notification control
248 *
249 * With a priority the routine returns a queue entry if the queue has free entries. If the queue
250 * is full(no free entries) than no entry is returned and the function returns 0 otherwise 1 is
251 * returned.
252 */
253
254static int aac_get_entry (struct aac_dev * dev, u32 qid, struct aac_entry **entry, u32 * index, unsigned long *nonotify)
255{
256 struct aac_queue * q;
Mark Haverkampbed30de2005-08-03 15:38:51 -0700257 unsigned long idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
259 /*
260 * All of the queues wrap when they reach the end, so we check
261 * to see if they have reached the end and if they have we just
262 * set the index back to zero. This is a wrap. You could or off
263 * the high bits in all updates but this is a bit faster I think.
264 */
265
266 q = &dev->queues->queue[qid];
Mark Haverkampbed30de2005-08-03 15:38:51 -0700267
268 idx = *index = le32_to_cpu(*(q->headers.producer));
269 /* Interrupt Moderation, only interrupt for first two entries */
270 if (idx != le32_to_cpu(*(q->headers.consumer))) {
271 if (--idx == 0) {
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700272 if (qid == AdapNormCmdQueue)
Mark Haverkampbed30de2005-08-03 15:38:51 -0700273 idx = ADAP_NORM_CMD_ENTRIES;
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700274 else
Mark Haverkampbed30de2005-08-03 15:38:51 -0700275 idx = ADAP_NORM_RESP_ENTRIES;
276 }
277 if (idx != le32_to_cpu(*(q->headers.consumer)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 *nonotify = 1;
Mark Haverkampbed30de2005-08-03 15:38:51 -0700279 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700281 if (qid == AdapNormCmdQueue) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 if (*index >= ADAP_NORM_CMD_ENTRIES)
283 *index = 0; /* Wrap to front of the Producer Queue. */
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700284 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 if (*index >= ADAP_NORM_RESP_ENTRIES)
286 *index = 0; /* Wrap to front of the Producer Queue. */
287 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289 if ((*index + 1) == le32_to_cpu(*(q->headers.consumer))) { /* Queue is full */
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700290 printk(KERN_WARNING "Queue %d full, %u outstanding.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 qid, q->numpending);
292 return 0;
293 } else {
294 *entry = q->base + *index;
295 return 1;
296 }
297}
298
299/**
300 * aac_queue_get - get the next free QE
301 * @dev: Adapter
302 * @index: Returned index
303 * @priority: Priority of fib
304 * @fib: Fib to associate with the queue entry
305 * @wait: Wait if queue full
306 * @fibptr: Driver fib object to go with fib
307 * @nonotify: Don't notify the adapter
308 *
309 * Gets the next free QE off the requested priorty adapter command
310 * queue and associates the Fib with the QE. The QE represented by
311 * index is ready to insert on the queue when this routine returns
312 * success.
313 */
314
Mark Haverkamp28713322007-01-23 14:59:20 -0800315int aac_queue_get(struct aac_dev * dev, u32 * index, u32 qid, struct hw_fib * hw_fib, int wait, struct fib * fibptr, unsigned long *nonotify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316{
317 struct aac_entry * entry = NULL;
318 int map = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700320 if (qid == AdapNormCmdQueue) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 /* if no entries wait for some if caller wants to */
322 while (!aac_get_entry(dev, qid, &entry, index, nonotify))
323 {
324 printk(KERN_ERR "GetEntries failed\n");
325 }
326 /*
327 * Setup queue entry with a command, status and fib mapped
328 */
329 entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size));
330 map = 1;
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700331 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 while(!aac_get_entry(dev, qid, &entry, index, nonotify))
333 {
334 /* if no entries wait for some if caller wants to */
335 }
336 /*
337 * Setup queue entry with command, status and fib mapped
338 */
339 entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size));
340 entry->addr = hw_fib->header.SenderFibAddress;
341 /* Restore adapters pointer to the FIB */
342 hw_fib->header.ReceiverFibAddress = hw_fib->header.SenderFibAddress; /* Let the adapter now where to find its data */
343 map = 0;
344 }
345 /*
346 * If MapFib is true than we need to map the Fib and put pointers
347 * in the queue entry.
348 */
349 if (map)
350 entry->addr = cpu_to_le32(fibptr->hw_fib_pa);
351 return 0;
352}
353
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354/*
355 * Define the highest level of host to adapter communication routines.
356 * These routines will support host to adapter FS commuication. These
357 * routines have no knowledge of the commuication method used. This level
358 * sends and receives FIBs. This level has no knowledge of how these FIBs
359 * get passed back and forth.
360 */
361
362/**
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800363 * aac_fib_send - send a fib to the adapter
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 * @command: Command to send
365 * @fibptr: The fib
366 * @size: Size of fib data area
367 * @priority: Priority of Fib
368 * @wait: Async/sync select
369 * @reply: True if a reply is wanted
370 * @callback: Called with reply
371 * @callback_data: Passed to callback
372 *
373 * Sends the requested FIB to the adapter and optionally will wait for a
374 * response FIB. If the caller does not wish to wait for a response than
375 * an event to wait on must be supplied. This event will be set when a
376 * response FIB is received from the adapter.
377 */
378
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800379int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
380 int priority, int wait, int reply, fib_callback callback,
381 void *callback_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 struct aac_dev * dev = fibptr->dev;
Mark Haverkampa8166a52007-03-15 10:26:22 -0700384 struct hw_fib * hw_fib = fibptr->hw_fib_va;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 unsigned long flags = 0;
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700386 unsigned long qflags;
387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 if (!(hw_fib->header.XferState & cpu_to_le32(HostOwned)))
389 return -EBUSY;
390 /*
391 * There are 5 cases with the wait and reponse requested flags.
392 * The only invalid cases are if the caller requests to wait and
393 * does not request a response and if the caller does not want a
394 * response and the Fib is not allocated from pool. If a response
395 * is not requesed the Fib will just be deallocaed by the DPC
396 * routine when the response comes back from the adapter. No
397 * further processing will be done besides deleting the Fib. We
398 * will have a debug mode where the adapter can notify the host
399 * it had a problem and the host can log that fact.
400 */
401 if (wait && !reply) {
402 return -EINVAL;
403 } else if (!wait && reply) {
404 hw_fib->header.XferState |= cpu_to_le32(Async | ResponseExpected);
405 FIB_COUNTER_INCREMENT(aac_config.AsyncSent);
406 } else if (!wait && !reply) {
407 hw_fib->header.XferState |= cpu_to_le32(NoResponseExpected);
408 FIB_COUNTER_INCREMENT(aac_config.NoResponseSent);
409 } else if (wait && reply) {
410 hw_fib->header.XferState |= cpu_to_le32(ResponseExpected);
411 FIB_COUNTER_INCREMENT(aac_config.NormalSent);
412 }
413 /*
414 * Map the fib into 32bits by using the fib number
415 */
416
Mark Haverkamp8e0c5eb2005-10-24 10:52:22 -0700417 hw_fib->header.SenderFibAddress = cpu_to_le32(((u32)(fibptr - dev->fibs)) << 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 hw_fib->header.SenderData = (u32)(fibptr - dev->fibs);
419 /*
420 * Set FIB state to indicate where it came from and if we want a
421 * response from the adapter. Also load the command from the
422 * caller.
423 *
424 * Map the hw fib pointer as a 32bit value
425 */
426 hw_fib->header.Command = cpu_to_le16(command);
427 hw_fib->header.XferState |= cpu_to_le32(SentFromHost);
Mark Haverkampa8166a52007-03-15 10:26:22 -0700428 fibptr->hw_fib_va->header.Flags = 0; /* 0 the flags field - internal only*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 /*
430 * Set the size of the Fib we want to send to the adapter
431 */
432 hw_fib->header.Size = cpu_to_le16(sizeof(struct aac_fibhdr) + size);
433 if (le16_to_cpu(hw_fib->header.Size) > le16_to_cpu(hw_fib->header.SenderSize)) {
434 return -EMSGSIZE;
435 }
436 /*
437 * Get a queue entry connect the FIB to it and send an notify
438 * the adapter a command is ready.
439 */
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700440 hw_fib->header.XferState |= cpu_to_le32(NormalPriority);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 /*
443 * Fill in the Callback and CallbackContext if we are not
444 * going to wait.
445 */
446 if (!wait) {
447 fibptr->callback = callback;
448 fibptr->callback_data = callback_data;
449 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
451 fibptr->done = 0;
452 fibptr->flags = 0;
453
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700454 FIB_COUNTER_INCREMENT(aac_config.FibsSent);
455
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700456 dprintk((KERN_DEBUG "Fib contents:.\n"));
Mark Haverkamp8e0c5eb2005-10-24 10:52:22 -0700457 dprintk((KERN_DEBUG " Command = %d.\n", le32_to_cpu(hw_fib->header.Command)));
458 dprintk((KERN_DEBUG " SubCommand = %d.\n", le32_to_cpu(((struct aac_query_mount *)fib_data(fibptr))->command)));
459 dprintk((KERN_DEBUG " XferState = %x.\n", le32_to_cpu(hw_fib->header.XferState)));
Mark Haverkampa8166a52007-03-15 10:26:22 -0700460 dprintk((KERN_DEBUG " hw_fib va being sent=%p\n",fibptr->hw_fib_va));
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700461 dprintk((KERN_DEBUG " hw_fib pa being sent=%lx\n",(ulong)fibptr->hw_fib_pa));
462 dprintk((KERN_DEBUG " fib being sent=%p\n",fibptr));
463
Mark Haverkampc8f7b072006-08-03 08:02:24 -0700464 if (!dev->queues)
Mark Haverkamp651013552006-09-19 08:59:23 -0700465 return -EBUSY;
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700466
467 if(wait)
468 spin_lock_irqsave(&fibptr->event_lock, flags);
Mark Haverkamp28713322007-01-23 14:59:20 -0800469 aac_adapter_deliver(fibptr);
Mark Haverkamp8e0c5eb2005-10-24 10:52:22 -0700470
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 /*
472 * If the caller wanted us to wait for response wait now.
473 */
474
475 if (wait) {
476 spin_unlock_irqrestore(&fibptr->event_lock, flags);
Mark Haverkamp92033442005-09-20 12:56:50 -0700477 /* Only set for first known interruptable command */
478 if (wait < 0) {
479 /*
480 * *VERY* Dangerous to time out a command, the
481 * assumption is made that we have no hope of
482 * functioning because an interrupt routing or other
483 * hardware failure has occurred.
484 */
485 unsigned long count = 36000000L; /* 3 minutes */
Mark Haverkamp92033442005-09-20 12:56:50 -0700486 while (down_trylock(&fibptr->event_wait)) {
Mark Haverkamp33524b72006-11-21 10:40:08 -0800487 int blink;
Mark Haverkamp92033442005-09-20 12:56:50 -0700488 if (--count == 0) {
Mark Haverkamp28713322007-01-23 14:59:20 -0800489 struct aac_queue * q = &dev->queues->queue[AdapNormCmdQueue];
Mark Haverkamp92033442005-09-20 12:56:50 -0700490 spin_lock_irqsave(q->lock, qflags);
491 q->numpending--;
Mark Haverkamp92033442005-09-20 12:56:50 -0700492 spin_unlock_irqrestore(q->lock, qflags);
493 if (wait == -1) {
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800494 printk(KERN_ERR "aacraid: aac_fib_send: first asynchronous command timed out.\n"
Mark Haverkamp92033442005-09-20 12:56:50 -0700495 "Usually a result of a PCI interrupt routing problem;\n"
496 "update mother board BIOS or consider utilizing one of\n"
497 "the SAFE mode kernel options (acpi, apic etc)\n");
498 }
499 return -ETIMEDOUT;
500 }
Mark Haverkamp33524b72006-11-21 10:40:08 -0800501 if ((blink = aac_adapter_check_health(dev)) > 0) {
502 if (wait == -1) {
503 printk(KERN_ERR "aacraid: aac_fib_send: adapter blinkLED 0x%x.\n"
504 "Usually a result of a serious unrecoverable hardware problem\n",
505 blink);
506 }
507 return -EFAULT;
508 }
Mark Haverkamp92033442005-09-20 12:56:50 -0700509 udelay(5);
510 }
Mark Haverkamp33bb3b22007-03-15 10:27:21 -0700511 } else
512 (void)down_interruptible(&fibptr->event_wait);
513 spin_lock_irqsave(&fibptr->event_lock, flags);
514 if (fibptr->done == 0) {
515 fibptr->done = 2; /* Tell interrupt we aborted */
Mark Haverkampc8f7b072006-08-03 08:02:24 -0700516 spin_unlock_irqrestore(&fibptr->event_lock, flags);
Mark Haverkamp33bb3b22007-03-15 10:27:21 -0700517 return -EINTR;
Mark Haverkampc8f7b072006-08-03 08:02:24 -0700518 }
Mark Haverkamp33bb3b22007-03-15 10:27:21 -0700519 spin_unlock_irqrestore(&fibptr->event_lock, flags);
Eric Sesterhenn125e1872006-06-23 02:06:06 -0700520 BUG_ON(fibptr->done == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521
522 if((fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT)){
523 return -ETIMEDOUT;
524 } else {
525 return 0;
526 }
527 }
528 /*
529 * If the user does not want a response than return success otherwise
530 * return pending
531 */
532 if (reply)
533 return -EINPROGRESS;
534 else
535 return 0;
536}
537
538/**
539 * aac_consumer_get - get the top of the queue
540 * @dev: Adapter
541 * @q: Queue
542 * @entry: Return entry
543 *
544 * Will return a pointer to the entry on the top of the queue requested that
545 * we are a consumer of, and return the address of the queue entry. It does
546 * not change the state of the queue.
547 */
548
549int aac_consumer_get(struct aac_dev * dev, struct aac_queue * q, struct aac_entry **entry)
550{
551 u32 index;
552 int status;
553 if (le32_to_cpu(*q->headers.producer) == le32_to_cpu(*q->headers.consumer)) {
554 status = 0;
555 } else {
556 /*
557 * The consumer index must be wrapped if we have reached
558 * the end of the queue, else we just use the entry
559 * pointed to by the header index
560 */
561 if (le32_to_cpu(*q->headers.consumer) >= q->entries)
562 index = 0;
563 else
564 index = le32_to_cpu(*q->headers.consumer);
565 *entry = q->base + index;
566 status = 1;
567 }
568 return(status);
569}
570
571/**
572 * aac_consumer_free - free consumer entry
573 * @dev: Adapter
574 * @q: Queue
575 * @qid: Queue ident
576 *
577 * Frees up the current top of the queue we are a consumer of. If the
578 * queue was full notify the producer that the queue is no longer full.
579 */
580
581void aac_consumer_free(struct aac_dev * dev, struct aac_queue *q, u32 qid)
582{
583 int wasfull = 0;
584 u32 notify;
585
586 if ((le32_to_cpu(*q->headers.producer)+1) == le32_to_cpu(*q->headers.consumer))
587 wasfull = 1;
588
589 if (le32_to_cpu(*q->headers.consumer) >= q->entries)
590 *q->headers.consumer = cpu_to_le32(1);
591 else
592 *q->headers.consumer = cpu_to_le32(le32_to_cpu(*q->headers.consumer)+1);
593
594 if (wasfull) {
595 switch (qid) {
596
597 case HostNormCmdQueue:
598 notify = HostNormCmdNotFull;
599 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 case HostNormRespQueue:
601 notify = HostNormRespNotFull;
602 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 default:
604 BUG();
605 return;
606 }
607 aac_adapter_notify(dev, notify);
608 }
609}
610
611/**
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800612 * aac_fib_adapter_complete - complete adapter issued fib
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 * @fibptr: fib to complete
614 * @size: size of fib
615 *
616 * Will do all necessary work to complete a FIB that was sent from
617 * the adapter.
618 */
619
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800620int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621{
Mark Haverkampa8166a52007-03-15 10:26:22 -0700622 struct hw_fib * hw_fib = fibptr->hw_fib_va;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 struct aac_dev * dev = fibptr->dev;
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700624 struct aac_queue * q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 unsigned long nointr = 0;
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700626 unsigned long qflags;
627
628 if (hw_fib->header.XferState == 0) {
Mark Haverkamp28713322007-01-23 14:59:20 -0800629 if (dev->comm_interface == AAC_COMM_MESSAGE)
Mark Haverkamp8e0c5eb2005-10-24 10:52:22 -0700630 kfree (hw_fib);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 return 0;
Mark Haverkamp1640a2c2005-09-20 12:57:11 -0700632 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 /*
634 * If we plan to do anything check the structure type first.
635 */
636 if ( hw_fib->header.StructType != FIB_MAGIC ) {
Mark Haverkamp28713322007-01-23 14:59:20 -0800637 if (dev->comm_interface == AAC_COMM_MESSAGE)
Mark Haverkamp8e0c5eb2005-10-24 10:52:22 -0700638 kfree (hw_fib);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 return -EINVAL;
640 }
641 /*
642 * This block handles the case where the adapter had sent us a
643 * command and we have finished processing the command. We
644 * call completeFib when we are done processing the command
645 * and want to send a response back to the adapter. This will
646 * send the completed cdb to the adapter.
647 */
648 if (hw_fib->header.XferState & cpu_to_le32(SentFromAdapter)) {
Mark Haverkamp28713322007-01-23 14:59:20 -0800649 if (dev->comm_interface == AAC_COMM_MESSAGE) {
Mark Haverkamp8e0c5eb2005-10-24 10:52:22 -0700650 kfree (hw_fib);
651 } else {
652 u32 index;
653 hw_fib->header.XferState |= cpu_to_le32(HostProcessed);
654 if (size) {
655 size += sizeof(struct aac_fibhdr);
656 if (size > le16_to_cpu(hw_fib->header.SenderSize))
657 return -EMSGSIZE;
658 hw_fib->header.Size = cpu_to_le16(size);
659 }
660 q = &dev->queues->queue[AdapNormRespQueue];
661 spin_lock_irqsave(q->lock, qflags);
662 aac_queue_get(dev, &index, AdapNormRespQueue, hw_fib, 1, NULL, &nointr);
663 *(q->headers.producer) = cpu_to_le32(index + 1);
664 spin_unlock_irqrestore(q->lock, qflags);
665 if (!(nointr & (int)aac_config.irq_mod))
666 aac_adapter_notify(dev, AdapNormRespQueue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 }
668 }
669 else
670 {
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800671 printk(KERN_WARNING "aac_fib_adapter_complete: Unknown xferstate detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 BUG();
673 }
674 return 0;
675}
676
677/**
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800678 * aac_fib_complete - fib completion handler
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 * @fib: FIB to complete
680 *
681 * Will do all necessary work to complete a FIB.
682 */
683
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800684int aac_fib_complete(struct fib *fibptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685{
Mark Haverkampa8166a52007-03-15 10:26:22 -0700686 struct hw_fib * hw_fib = fibptr->hw_fib_va;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
688 /*
689 * Check for a fib which has already been completed
690 */
691
692 if (hw_fib->header.XferState == 0)
693 return 0;
694 /*
695 * If we plan to do anything check the structure type first.
696 */
697
698 if (hw_fib->header.StructType != FIB_MAGIC)
699 return -EINVAL;
700 /*
701 * This block completes a cdb which orginated on the host and we
702 * just need to deallocate the cdb or reinit it. At this point the
703 * command is complete that we had sent to the adapter and this
704 * cdb could be reused.
705 */
706 if((hw_fib->header.XferState & cpu_to_le32(SentFromHost)) &&
707 (hw_fib->header.XferState & cpu_to_le32(AdapterProcessed)))
708 {
709 fib_dealloc(fibptr);
710 }
711 else if(hw_fib->header.XferState & cpu_to_le32(SentFromHost))
712 {
713 /*
714 * This handles the case when the host has aborted the I/O
715 * to the adapter because the adapter is not responding
716 */
717 fib_dealloc(fibptr);
718 } else if(hw_fib->header.XferState & cpu_to_le32(HostOwned)) {
719 fib_dealloc(fibptr);
720 } else {
721 BUG();
722 }
723 return 0;
724}
725
726/**
727 * aac_printf - handle printf from firmware
728 * @dev: Adapter
729 * @val: Message info
730 *
731 * Print a message passed to us by the controller firmware on the
732 * Adaptec board
733 */
734
735void aac_printf(struct aac_dev *dev, u32 val)
736{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 char *cp = dev->printfbuf;
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700738 if (dev->printf_enabled)
739 {
740 int length = val & 0xffff;
741 int level = (val >> 16) & 0xffff;
742
743 /*
744 * The size of the printfbuf is set in port.c
745 * There is no variable or define for it
746 */
747 if (length > 255)
748 length = 255;
749 if (cp[length] != 0)
750 cp[length] = 0;
751 if (level == LOG_AAC_HIGH_ERROR)
Mark Haverkamp1241f352006-03-27 09:44:23 -0800752 printk(KERN_WARNING "%s:%s", dev->name, cp);
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700753 else
Mark Haverkamp1241f352006-03-27 09:44:23 -0800754 printk(KERN_INFO "%s:%s", dev->name, cp);
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700755 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 memset(cp, 0, 256);
757}
758
Mark Haverkamp131256c2005-09-26 13:04:56 -0700759
760/**
761 * aac_handle_aif - Handle a message from the firmware
762 * @dev: Which adapter this fib is from
763 * @fibptr: Pointer to fibptr from adapter
764 *
765 * This routine handles a driver notify fib from the adapter and
766 * dispatches it to the appropriate routine for handling.
767 */
768
Mark Haverkamp31876f32006-03-27 09:43:55 -0800769#define AIF_SNIFF_TIMEOUT (30*HZ)
Mark Haverkamp131256c2005-09-26 13:04:56 -0700770static void aac_handle_aif(struct aac_dev * dev, struct fib * fibptr)
771{
Mark Haverkampa8166a52007-03-15 10:26:22 -0700772 struct hw_fib * hw_fib = fibptr->hw_fib_va;
Mark Haverkamp131256c2005-09-26 13:04:56 -0700773 struct aac_aifcmd * aifcmd = (struct aac_aifcmd *)hw_fib->data;
Mark Haverkamp131256c2005-09-26 13:04:56 -0700774 u32 container;
775 struct scsi_device *device;
776 enum {
777 NOTHING,
778 DELETE,
779 ADD,
780 CHANGE
781 } device_config_needed;
782
783 /* Sniff for container changes */
784
Mark Haverkampc8f7b072006-08-03 08:02:24 -0700785 if (!dev || !dev->fsa_dev)
Mark Haverkamp131256c2005-09-26 13:04:56 -0700786 return;
787 container = (u32)-1;
788
789 /*
790 * We have set this up to try and minimize the number of
791 * re-configures that take place. As a result of this when
792 * certain AIF's come in we will set a flag waiting for another
793 * type of AIF before setting the re-config flag.
794 */
795 switch (le32_to_cpu(aifcmd->command)) {
796 case AifCmdDriverNotify:
797 switch (le32_to_cpu(((u32 *)aifcmd->data)[0])) {
798 /*
799 * Morph or Expand complete
800 */
801 case AifDenMorphComplete:
802 case AifDenVolumeExtendComplete:
803 container = le32_to_cpu(((u32 *)aifcmd->data)[1]);
804 if (container >= dev->maximum_num_containers)
805 break;
806
807 /*
Christoph Hellwigf64a1812005-10-31 18:32:08 +0100808 * Find the scsi_device associated with the SCSI
Mark Haverkamp131256c2005-09-26 13:04:56 -0700809 * address. Make sure we have the right array, and if
810 * so set the flag to initiate a new re-config once we
811 * see an AifEnConfigChange AIF come through.
812 */
813
814 if ((dev != NULL) && (dev->scsi_host_ptr != NULL)) {
815 device = scsi_device_lookup(dev->scsi_host_ptr,
816 CONTAINER_TO_CHANNEL(container),
817 CONTAINER_TO_ID(container),
818 CONTAINER_TO_LUN(container));
819 if (device) {
820 dev->fsa_dev[container].config_needed = CHANGE;
821 dev->fsa_dev[container].config_waiting_on = AifEnConfigChange;
Mark Haverkamp31876f32006-03-27 09:43:55 -0800822 dev->fsa_dev[container].config_waiting_stamp = jiffies;
Mark Haverkamp131256c2005-09-26 13:04:56 -0700823 scsi_device_put(device);
824 }
825 }
826 }
827
828 /*
829 * If we are waiting on something and this happens to be
830 * that thing then set the re-configure flag.
831 */
832 if (container != (u32)-1) {
833 if (container >= dev->maximum_num_containers)
834 break;
Mark Haverkamp31876f32006-03-27 09:43:55 -0800835 if ((dev->fsa_dev[container].config_waiting_on ==
836 le32_to_cpu(*(u32 *)aifcmd->data)) &&
837 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
Mark Haverkamp131256c2005-09-26 13:04:56 -0700838 dev->fsa_dev[container].config_waiting_on = 0;
839 } else for (container = 0;
840 container < dev->maximum_num_containers; ++container) {
Mark Haverkamp31876f32006-03-27 09:43:55 -0800841 if ((dev->fsa_dev[container].config_waiting_on ==
842 le32_to_cpu(*(u32 *)aifcmd->data)) &&
843 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
Mark Haverkamp131256c2005-09-26 13:04:56 -0700844 dev->fsa_dev[container].config_waiting_on = 0;
845 }
846 break;
847
848 case AifCmdEventNotify:
849 switch (le32_to_cpu(((u32 *)aifcmd->data)[0])) {
850 /*
851 * Add an Array.
852 */
853 case AifEnAddContainer:
854 container = le32_to_cpu(((u32 *)aifcmd->data)[1]);
855 if (container >= dev->maximum_num_containers)
856 break;
857 dev->fsa_dev[container].config_needed = ADD;
858 dev->fsa_dev[container].config_waiting_on =
859 AifEnConfigChange;
Mark Haverkamp31876f32006-03-27 09:43:55 -0800860 dev->fsa_dev[container].config_waiting_stamp = jiffies;
Mark Haverkamp131256c2005-09-26 13:04:56 -0700861 break;
862
863 /*
864 * Delete an Array.
865 */
866 case AifEnDeleteContainer:
867 container = le32_to_cpu(((u32 *)aifcmd->data)[1]);
868 if (container >= dev->maximum_num_containers)
869 break;
870 dev->fsa_dev[container].config_needed = DELETE;
871 dev->fsa_dev[container].config_waiting_on =
872 AifEnConfigChange;
Mark Haverkamp31876f32006-03-27 09:43:55 -0800873 dev->fsa_dev[container].config_waiting_stamp = jiffies;
Mark Haverkamp131256c2005-09-26 13:04:56 -0700874 break;
875
876 /*
877 * Container change detected. If we currently are not
878 * waiting on something else, setup to wait on a Config Change.
879 */
880 case AifEnContainerChange:
881 container = le32_to_cpu(((u32 *)aifcmd->data)[1]);
882 if (container >= dev->maximum_num_containers)
883 break;
Mark Haverkamp31876f32006-03-27 09:43:55 -0800884 if (dev->fsa_dev[container].config_waiting_on &&
885 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
Mark Haverkamp131256c2005-09-26 13:04:56 -0700886 break;
887 dev->fsa_dev[container].config_needed = CHANGE;
888 dev->fsa_dev[container].config_waiting_on =
889 AifEnConfigChange;
Mark Haverkamp31876f32006-03-27 09:43:55 -0800890 dev->fsa_dev[container].config_waiting_stamp = jiffies;
Mark Haverkamp131256c2005-09-26 13:04:56 -0700891 break;
892
893 case AifEnConfigChange:
894 break;
895
896 }
897
898 /*
899 * If we are waiting on something and this happens to be
900 * that thing then set the re-configure flag.
901 */
902 if (container != (u32)-1) {
903 if (container >= dev->maximum_num_containers)
904 break;
Mark Haverkamp31876f32006-03-27 09:43:55 -0800905 if ((dev->fsa_dev[container].config_waiting_on ==
906 le32_to_cpu(*(u32 *)aifcmd->data)) &&
907 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
Mark Haverkamp131256c2005-09-26 13:04:56 -0700908 dev->fsa_dev[container].config_waiting_on = 0;
909 } else for (container = 0;
910 container < dev->maximum_num_containers; ++container) {
Mark Haverkamp31876f32006-03-27 09:43:55 -0800911 if ((dev->fsa_dev[container].config_waiting_on ==
912 le32_to_cpu(*(u32 *)aifcmd->data)) &&
913 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
Mark Haverkamp131256c2005-09-26 13:04:56 -0700914 dev->fsa_dev[container].config_waiting_on = 0;
915 }
916 break;
917
918 case AifCmdJobProgress:
919 /*
920 * These are job progress AIF's. When a Clear is being
921 * done on a container it is initially created then hidden from
922 * the OS. When the clear completes we don't get a config
923 * change so we monitor the job status complete on a clear then
924 * wait for a container change.
925 */
926
927 if ((((u32 *)aifcmd->data)[1] == cpu_to_le32(AifJobCtrZero))
928 && ((((u32 *)aifcmd->data)[6] == ((u32 *)aifcmd->data)[5])
929 || (((u32 *)aifcmd->data)[4] == cpu_to_le32(AifJobStsSuccess)))) {
930 for (container = 0;
931 container < dev->maximum_num_containers;
932 ++container) {
933 /*
934 * Stomp on all config sequencing for all
935 * containers?
936 */
937 dev->fsa_dev[container].config_waiting_on =
938 AifEnContainerChange;
939 dev->fsa_dev[container].config_needed = ADD;
Mark Haverkamp31876f32006-03-27 09:43:55 -0800940 dev->fsa_dev[container].config_waiting_stamp =
941 jiffies;
Mark Haverkamp131256c2005-09-26 13:04:56 -0700942 }
943 }
944 if ((((u32 *)aifcmd->data)[1] == cpu_to_le32(AifJobCtrZero))
945 && (((u32 *)aifcmd->data)[6] == 0)
946 && (((u32 *)aifcmd->data)[4] == cpu_to_le32(AifJobStsRunning))) {
947 for (container = 0;
948 container < dev->maximum_num_containers;
949 ++container) {
950 /*
951 * Stomp on all config sequencing for all
952 * containers?
953 */
954 dev->fsa_dev[container].config_waiting_on =
955 AifEnContainerChange;
956 dev->fsa_dev[container].config_needed = DELETE;
Mark Haverkamp31876f32006-03-27 09:43:55 -0800957 dev->fsa_dev[container].config_waiting_stamp =
958 jiffies;
Mark Haverkamp131256c2005-09-26 13:04:56 -0700959 }
960 }
961 break;
962 }
963
964 device_config_needed = NOTHING;
965 for (container = 0; container < dev->maximum_num_containers;
966 ++container) {
Mark Haverkamp31876f32006-03-27 09:43:55 -0800967 if ((dev->fsa_dev[container].config_waiting_on == 0) &&
968 (dev->fsa_dev[container].config_needed != NOTHING) &&
969 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) {
Mark Haverkamp131256c2005-09-26 13:04:56 -0700970 device_config_needed =
971 dev->fsa_dev[container].config_needed;
972 dev->fsa_dev[container].config_needed = NOTHING;
973 break;
974 }
975 }
976 if (device_config_needed == NOTHING)
977 return;
978
979 /*
980 * If we decided that a re-configuration needs to be done,
981 * schedule it here on the way out the door, please close the door
982 * behind you.
983 */
984
Mark Haverkamp131256c2005-09-26 13:04:56 -0700985 /*
Christoph Hellwigf64a1812005-10-31 18:32:08 +0100986 * Find the scsi_device associated with the SCSI address,
Mark Haverkamp131256c2005-09-26 13:04:56 -0700987 * and mark it as changed, invalidating the cache. This deals
988 * with changes to existing device IDs.
989 */
990
991 if (!dev || !dev->scsi_host_ptr)
992 return;
993 /*
Mark Haverkampbfb35aa82006-02-01 09:30:55 -0800994 * force reload of disk info via aac_probe_container
Mark Haverkamp131256c2005-09-26 13:04:56 -0700995 */
996 if ((device_config_needed == CHANGE)
997 && (dev->fsa_dev[container].valid == 1))
998 dev->fsa_dev[container].valid = 2;
999 if ((device_config_needed == CHANGE) ||
1000 (device_config_needed == ADD))
Mark Haverkampbfb35aa82006-02-01 09:30:55 -08001001 aac_probe_container(dev, container);
Mark Haverkamp131256c2005-09-26 13:04:56 -07001002 device = scsi_device_lookup(dev->scsi_host_ptr,
1003 CONTAINER_TO_CHANNEL(container),
1004 CONTAINER_TO_ID(container),
1005 CONTAINER_TO_LUN(container));
1006 if (device) {
1007 switch (device_config_needed) {
1008 case DELETE:
Mark Haverkamp131256c2005-09-26 13:04:56 -07001009 case CHANGE:
Mark Haverkamp131256c2005-09-26 13:04:56 -07001010 scsi_rescan_device(&device->sdev_gendev);
1011
1012 default:
1013 break;
1014 }
1015 scsi_device_put(device);
1016 }
1017 if (device_config_needed == ADD) {
1018 scsi_add_device(dev->scsi_host_ptr,
1019 CONTAINER_TO_CHANNEL(container),
1020 CONTAINER_TO_ID(container),
1021 CONTAINER_TO_LUN(container));
1022 }
1023
1024}
1025
Mark Haverkamp8c867b22006-08-03 08:03:30 -07001026static int _aac_reset_adapter(struct aac_dev *aac)
1027{
1028 int index, quirks;
Mark Haverkamp8c867b22006-08-03 08:03:30 -07001029 int retval;
1030 struct Scsi_Host *host;
1031 struct scsi_device *dev;
1032 struct scsi_cmnd *command;
1033 struct scsi_cmnd *command_list;
1034
1035 /*
1036 * Assumptions:
1037 * - host is locked.
1038 * - in_reset is asserted, so no new i/o is getting to the
1039 * card.
1040 * - The card is dead.
1041 */
1042 host = aac->scsi_host_ptr;
1043 scsi_block_requests(host);
1044 aac_adapter_disable_int(aac);
1045 spin_unlock_irq(host->host_lock);
1046 kthread_stop(aac->thread);
1047
1048 /*
1049 * If a positive health, means in a known DEAD PANIC
1050 * state and the adapter could be reset to `try again'.
1051 */
Mark Haverkamp84188522007-03-15 10:26:05 -07001052 retval = aac_adapter_restart(aac, aac_adapter_check_health(aac));
Mark Haverkamp8c867b22006-08-03 08:03:30 -07001053
1054 if (retval)
1055 goto out;
Mark Haverkamp8c867b22006-08-03 08:03:30 -07001056
Mark Haverkampd18b4482006-11-21 10:40:31 -08001057 /*
1058 * Loop through the fibs, close the synchronous FIBS
1059 */
Mark Haverkamp33bb3b22007-03-15 10:27:21 -07001060 for (retval = 1, index = 0; index < (aac->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); index++) {
Mark Haverkampd18b4482006-11-21 10:40:31 -08001061 struct fib *fib = &aac->fibs[index];
Mark Haverkampa8166a52007-03-15 10:26:22 -07001062 if (!(fib->hw_fib_va->header.XferState & cpu_to_le32(NoResponseExpected | Async)) &&
1063 (fib->hw_fib_va->header.XferState & cpu_to_le32(ResponseExpected))) {
Mark Haverkampd18b4482006-11-21 10:40:31 -08001064 unsigned long flagv;
1065 spin_lock_irqsave(&fib->event_lock, flagv);
1066 up(&fib->event_wait);
1067 spin_unlock_irqrestore(&fib->event_lock, flagv);
1068 schedule();
Mark Haverkamp33bb3b22007-03-15 10:27:21 -07001069 retval = 0;
Mark Haverkampd18b4482006-11-21 10:40:31 -08001070 }
1071 }
Mark Haverkamp33bb3b22007-03-15 10:27:21 -07001072 /* Give some extra time for ioctls to complete. */
1073 if (retval == 0)
1074 ssleep(2);
Mark Haverkamp8c867b22006-08-03 08:03:30 -07001075 index = aac->cardtype;
1076
1077 /*
1078 * Re-initialize the adapter, first free resources, then carefully
1079 * apply the initialization sequence to come back again. Only risk
1080 * is a change in Firmware dropping cache, it is assumed the caller
1081 * will ensure that i/o is queisced and the card is flushed in that
1082 * case.
1083 */
1084 aac_fib_map_free(aac);
1085 aac->hw_fib_va = NULL;
1086 aac->hw_fib_pa = 0;
1087 pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, aac->comm_phys);
1088 aac->comm_addr = NULL;
1089 aac->comm_phys = 0;
1090 kfree(aac->queues);
1091 aac->queues = NULL;
1092 free_irq(aac->pdev->irq, aac);
1093 kfree(aac->fsa_dev);
1094 aac->fsa_dev = NULL;
1095 if (aac_get_driver_ident(index)->quirks & AAC_QUIRK_31BIT) {
1096 if (((retval = pci_set_dma_mask(aac->pdev, DMA_32BIT_MASK))) ||
1097 ((retval = pci_set_consistent_dma_mask(aac->pdev, DMA_32BIT_MASK))))
1098 goto out;
1099 } else {
1100 if (((retval = pci_set_dma_mask(aac->pdev, 0x7FFFFFFFULL))) ||
1101 ((retval = pci_set_consistent_dma_mask(aac->pdev, 0x7FFFFFFFULL))))
1102 goto out;
1103 }
1104 if ((retval = (*(aac_get_driver_ident(index)->init))(aac)))
1105 goto out;
1106 if (aac_get_driver_ident(index)->quirks & AAC_QUIRK_31BIT)
1107 if ((retval = pci_set_dma_mask(aac->pdev, DMA_32BIT_MASK)))
1108 goto out;
1109 aac->thread = kthread_run(aac_command_thread, aac, aac->name);
1110 if (IS_ERR(aac->thread)) {
1111 retval = PTR_ERR(aac->thread);
1112 goto out;
1113 }
1114 (void)aac_get_adapter_info(aac);
1115 quirks = aac_get_driver_ident(index)->quirks;
1116 if ((quirks & AAC_QUIRK_34SG) && (host->sg_tablesize > 34)) {
1117 host->sg_tablesize = 34;
1118 host->max_sectors = (host->sg_tablesize * 8) + 112;
1119 }
1120 if ((quirks & AAC_QUIRK_17SG) && (host->sg_tablesize > 17)) {
1121 host->sg_tablesize = 17;
1122 host->max_sectors = (host->sg_tablesize * 8) + 112;
1123 }
1124 aac_get_config_status(aac, 1);
1125 aac_get_containers(aac);
1126 /*
1127 * This is where the assumption that the Adapter is quiesced
1128 * is important.
1129 */
1130 command_list = NULL;
1131 __shost_for_each_device(dev, host) {
1132 unsigned long flags;
1133 spin_lock_irqsave(&dev->list_lock, flags);
1134 list_for_each_entry(command, &dev->cmd_list, list)
1135 if (command->SCp.phase == AAC_OWNER_FIRMWARE) {
1136 command->SCp.buffer = (struct scatterlist *)command_list;
1137 command_list = command;
1138 }
1139 spin_unlock_irqrestore(&dev->list_lock, flags);
1140 }
1141 while ((command = command_list)) {
1142 command_list = (struct scsi_cmnd *)command->SCp.buffer;
1143 command->SCp.buffer = NULL;
1144 command->result = DID_OK << 16
1145 | COMMAND_COMPLETE << 8
1146 | SAM_STAT_TASK_SET_FULL;
1147 command->SCp.phase = AAC_OWNER_ERROR_HANDLER;
1148 command->scsi_done(command);
1149 }
1150 retval = 0;
1151
1152out:
1153 aac->in_reset = 0;
1154 scsi_unblock_requests(host);
1155 spin_lock_irq(host->host_lock);
1156 return retval;
1157}
1158
1159int aac_check_health(struct aac_dev * aac)
1160{
1161 int BlinkLED;
1162 unsigned long time_now, flagv = 0;
1163 struct list_head * entry;
1164 struct Scsi_Host * host;
1165
1166 /* Extending the scope of fib_lock slightly to protect aac->in_reset */
1167 if (spin_trylock_irqsave(&aac->fib_lock, flagv) == 0)
1168 return 0;
1169
1170 if (aac->in_reset || !(BlinkLED = aac_adapter_check_health(aac))) {
1171 spin_unlock_irqrestore(&aac->fib_lock, flagv);
1172 return 0; /* OK */
1173 }
1174
1175 aac->in_reset = 1;
1176
1177 /* Fake up an AIF:
1178 * aac_aifcmd.command = AifCmdEventNotify = 1
1179 * aac_aifcmd.seqnum = 0xFFFFFFFF
1180 * aac_aifcmd.data[0] = AifEnExpEvent = 23
1181 * aac_aifcmd.data[1] = AifExeFirmwarePanic = 3
1182 * aac.aifcmd.data[2] = AifHighPriority = 3
1183 * aac.aifcmd.data[3] = BlinkLED
1184 */
1185
1186 time_now = jiffies/HZ;
1187 entry = aac->fib_list.next;
1188
1189 /*
1190 * For each Context that is on the
1191 * fibctxList, make a copy of the
1192 * fib, and then set the event to wake up the
1193 * thread that is waiting for it.
1194 */
1195 while (entry != &aac->fib_list) {
1196 /*
1197 * Extract the fibctx
1198 */
1199 struct aac_fib_context *fibctx = list_entry(entry, struct aac_fib_context, next);
1200 struct hw_fib * hw_fib;
1201 struct fib * fib;
1202 /*
1203 * Check if the queue is getting
1204 * backlogged
1205 */
1206 if (fibctx->count > 20) {
1207 /*
1208 * It's *not* jiffies folks,
1209 * but jiffies / HZ, so do not
1210 * panic ...
1211 */
1212 u32 time_last = fibctx->jiffies;
1213 /*
1214 * Has it been > 2 minutes
1215 * since the last read off
1216 * the queue?
1217 */
1218 if ((time_now - time_last) > aif_timeout) {
1219 entry = entry->next;
1220 aac_close_fib_context(aac, fibctx);
1221 continue;
1222 }
1223 }
1224 /*
1225 * Warning: no sleep allowed while
1226 * holding spinlock
1227 */
1228 hw_fib = kmalloc(sizeof(struct hw_fib), GFP_ATOMIC);
1229 fib = kmalloc(sizeof(struct fib), GFP_ATOMIC);
1230 if (fib && hw_fib) {
1231 struct aac_aifcmd * aif;
1232
1233 memset(hw_fib, 0, sizeof(struct hw_fib));
1234 memset(fib, 0, sizeof(struct fib));
Mark Haverkampa8166a52007-03-15 10:26:22 -07001235 fib->hw_fib_va = hw_fib;
Mark Haverkamp8c867b22006-08-03 08:03:30 -07001236 fib->dev = aac;
1237 aac_fib_init(fib);
1238 fib->type = FSAFS_NTC_FIB_CONTEXT;
1239 fib->size = sizeof (struct fib);
1240 fib->data = hw_fib->data;
1241 aif = (struct aac_aifcmd *)hw_fib->data;
1242 aif->command = cpu_to_le32(AifCmdEventNotify);
1243 aif->seqnum = cpu_to_le32(0xFFFFFFFF);
1244 aif->data[0] = cpu_to_le32(AifEnExpEvent);
1245 aif->data[1] = cpu_to_le32(AifExeFirmwarePanic);
1246 aif->data[2] = cpu_to_le32(AifHighPriority);
1247 aif->data[3] = cpu_to_le32(BlinkLED);
1248
1249 /*
1250 * Put the FIB onto the
1251 * fibctx's fibs
1252 */
1253 list_add_tail(&fib->fiblink, &fibctx->fib_list);
1254 fibctx->count++;
1255 /*
1256 * Set the event to wake up the
1257 * thread that will waiting.
1258 */
1259 up(&fibctx->wait_sem);
1260 } else {
1261 printk(KERN_WARNING "aifd: didn't allocate NewFib.\n");
1262 kfree(fib);
1263 kfree(hw_fib);
1264 }
1265 entry = entry->next;
1266 }
1267
1268 spin_unlock_irqrestore(&aac->fib_lock, flagv);
1269
1270 if (BlinkLED < 0) {
1271 printk(KERN_ERR "%s: Host adapter dead %d\n", aac->name, BlinkLED);
1272 goto out;
1273 }
1274
1275 printk(KERN_ERR "%s: Host adapter BLINK LED 0x%x\n", aac->name, BlinkLED);
1276
1277 host = aac->scsi_host_ptr;
1278 spin_lock_irqsave(host->host_lock, flagv);
1279 BlinkLED = _aac_reset_adapter(aac);
1280 spin_unlock_irqrestore(host->host_lock, flagv);
1281 return BlinkLED;
1282
1283out:
1284 aac->in_reset = 0;
1285 return BlinkLED;
1286}
1287
1288
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289/**
1290 * aac_command_thread - command processing thread
1291 * @dev: Adapter to monitor
1292 *
1293 * Waits on the commandready event in it's queue. When the event gets set
1294 * it will pull FIBs off it's queue. It will continue to pull FIBs off
1295 * until the queue is empty. When the queue is empty it will wait for
1296 * more FIBs.
1297 */
1298
Christoph Hellwigfe273812006-02-14 18:45:06 +01001299int aac_command_thread(void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300{
Christoph Hellwigfe273812006-02-14 18:45:06 +01001301 struct aac_dev *dev = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 struct hw_fib *hw_fib, *hw_newfib;
1303 struct fib *fib, *newfib;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 struct aac_fib_context *fibctx;
1305 unsigned long flags;
1306 DECLARE_WAITQUEUE(wait, current);
1307
1308 /*
1309 * We can only have one thread per adapter for AIF's.
1310 */
1311 if (dev->aif_thread)
1312 return -EINVAL;
Christoph Hellwigfe273812006-02-14 18:45:06 +01001313
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 /*
1315 * Let the DPC know it has a place to send the AIF's to.
1316 */
1317 dev->aif_thread = 1;
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001318 add_wait_queue(&dev->queues->queue[HostNormCmdQueue].cmdready, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 set_current_state(TASK_INTERRUPTIBLE);
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001320 dprintk ((KERN_INFO "aac_command_thread start\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 while(1)
1322 {
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001323 spin_lock_irqsave(dev->queues->queue[HostNormCmdQueue].lock, flags);
1324 while(!list_empty(&(dev->queues->queue[HostNormCmdQueue].cmdq))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 struct list_head *entry;
1326 struct aac_aifcmd * aifcmd;
1327
1328 set_current_state(TASK_RUNNING);
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001329
1330 entry = dev->queues->queue[HostNormCmdQueue].cmdq.next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 list_del(entry);
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001332
1333 spin_unlock_irqrestore(dev->queues->queue[HostNormCmdQueue].lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 fib = list_entry(entry, struct fib, fiblink);
1335 /*
1336 * We will process the FIB here or pass it to a
1337 * worker thread that is TBD. We Really can't
1338 * do anything at this point since we don't have
1339 * anything defined for this thread to do.
1340 */
Mark Haverkampa8166a52007-03-15 10:26:22 -07001341 hw_fib = fib->hw_fib_va;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 memset(fib, 0, sizeof(struct fib));
1343 fib->type = FSAFS_NTC_FIB_CONTEXT;
1344 fib->size = sizeof( struct fib );
Mark Haverkampa8166a52007-03-15 10:26:22 -07001345 fib->hw_fib_va = hw_fib;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 fib->data = hw_fib->data;
1347 fib->dev = dev;
1348 /*
1349 * We only handle AifRequest fibs from the adapter.
1350 */
1351 aifcmd = (struct aac_aifcmd *) hw_fib->data;
1352 if (aifcmd->command == cpu_to_le32(AifCmdDriverNotify)) {
1353 /* Handle Driver Notify Events */
Mark Haverkamp131256c2005-09-26 13:04:56 -07001354 aac_handle_aif(dev, fib);
Mark Haverkamp 56b58712005-04-27 06:05:51 -07001355 *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK);
Mark Haverkampbfb35aa82006-02-01 09:30:55 -08001356 aac_fib_adapter_complete(fib, (u16)sizeof(u32));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 } else {
1358 struct list_head *entry;
1359 /* The u32 here is important and intended. We are using
1360 32bit wrapping time to fit the adapter field */
1361
1362 u32 time_now, time_last;
1363 unsigned long flagv;
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001364 unsigned num;
1365 struct hw_fib ** hw_fib_pool, ** hw_fib_p;
1366 struct fib ** fib_pool, ** fib_p;
Mark Haverkamp131256c2005-09-26 13:04:56 -07001367
1368 /* Sniff events */
1369 if ((aifcmd->command ==
1370 cpu_to_le32(AifCmdEventNotify)) ||
1371 (aifcmd->command ==
1372 cpu_to_le32(AifCmdJobProgress))) {
1373 aac_handle_aif(dev, fib);
1374 }
1375
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 time_now = jiffies/HZ;
1377
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001378 /*
1379 * Warning: no sleep allowed while
1380 * holding spinlock. We take the estimate
1381 * and pre-allocate a set of fibs outside the
1382 * lock.
1383 */
1384 num = le32_to_cpu(dev->init->AdapterFibsSize)
1385 / sizeof(struct hw_fib); /* some extra */
1386 spin_lock_irqsave(&dev->fib_lock, flagv);
1387 entry = dev->fib_list.next;
1388 while (entry != &dev->fib_list) {
1389 entry = entry->next;
1390 ++num;
1391 }
1392 spin_unlock_irqrestore(&dev->fib_lock, flagv);
1393 hw_fib_pool = NULL;
1394 fib_pool = NULL;
1395 if (num
1396 && ((hw_fib_pool = kmalloc(sizeof(struct hw_fib *) * num, GFP_KERNEL)))
1397 && ((fib_pool = kmalloc(sizeof(struct fib *) * num, GFP_KERNEL)))) {
1398 hw_fib_p = hw_fib_pool;
1399 fib_p = fib_pool;
1400 while (hw_fib_p < &hw_fib_pool[num]) {
1401 if (!(*(hw_fib_p++) = kmalloc(sizeof(struct hw_fib), GFP_KERNEL))) {
1402 --hw_fib_p;
1403 break;
1404 }
1405 if (!(*(fib_p++) = kmalloc(sizeof(struct fib), GFP_KERNEL))) {
1406 kfree(*(--hw_fib_p));
1407 break;
1408 }
1409 }
1410 if ((num = hw_fib_p - hw_fib_pool) == 0) {
1411 kfree(fib_pool);
1412 fib_pool = NULL;
1413 kfree(hw_fib_pool);
1414 hw_fib_pool = NULL;
1415 }
Jesper Juhlc9475cb2005-11-07 01:01:26 -08001416 } else {
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001417 kfree(hw_fib_pool);
1418 hw_fib_pool = NULL;
1419 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 spin_lock_irqsave(&dev->fib_lock, flagv);
1421 entry = dev->fib_list.next;
1422 /*
1423 * For each Context that is on the
1424 * fibctxList, make a copy of the
1425 * fib, and then set the event to wake up the
1426 * thread that is waiting for it.
1427 */
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001428 hw_fib_p = hw_fib_pool;
1429 fib_p = fib_pool;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 while (entry != &dev->fib_list) {
1431 /*
1432 * Extract the fibctx
1433 */
1434 fibctx = list_entry(entry, struct aac_fib_context, next);
1435 /*
1436 * Check if the queue is getting
1437 * backlogged
1438 */
1439 if (fibctx->count > 20)
1440 {
1441 /*
1442 * It's *not* jiffies folks,
1443 * but jiffies / HZ so do not
1444 * panic ...
1445 */
1446 time_last = fibctx->jiffies;
1447 /*
1448 * Has it been > 2 minutes
1449 * since the last read off
1450 * the queue?
1451 */
Mark Haverkamp404d9a92006-05-10 09:12:48 -07001452 if ((time_now - time_last) > aif_timeout) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 entry = entry->next;
1454 aac_close_fib_context(dev, fibctx);
1455 continue;
1456 }
1457 }
1458 /*
1459 * Warning: no sleep allowed while
1460 * holding spinlock
1461 */
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001462 if (hw_fib_p < &hw_fib_pool[num]) {
1463 hw_newfib = *hw_fib_p;
1464 *(hw_fib_p++) = NULL;
1465 newfib = *fib_p;
1466 *(fib_p++) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 /*
1468 * Make the copy of the FIB
1469 */
1470 memcpy(hw_newfib, hw_fib, sizeof(struct hw_fib));
1471 memcpy(newfib, fib, sizeof(struct fib));
Mark Haverkampa8166a52007-03-15 10:26:22 -07001472 newfib->hw_fib_va = hw_newfib;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 /*
1474 * Put the FIB onto the
1475 * fibctx's fibs
1476 */
1477 list_add_tail(&newfib->fiblink, &fibctx->fib_list);
1478 fibctx->count++;
1479 /*
1480 * Set the event to wake up the
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001481 * thread that is waiting.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 */
1483 up(&fibctx->wait_sem);
1484 } else {
1485 printk(KERN_WARNING "aifd: didn't allocate NewFib.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 }
1487 entry = entry->next;
1488 }
1489 /*
1490 * Set the status of this FIB
1491 */
Mark Haverkamp 56b58712005-04-27 06:05:51 -07001492 *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK);
Mark Haverkampbfb35aa82006-02-01 09:30:55 -08001493 aac_fib_adapter_complete(fib, sizeof(u32));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 spin_unlock_irqrestore(&dev->fib_lock, flagv);
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001495 /* Free up the remaining resources */
1496 hw_fib_p = hw_fib_pool;
1497 fib_p = fib_pool;
1498 while (hw_fib_p < &hw_fib_pool[num]) {
Jesper Juhlc9475cb2005-11-07 01:01:26 -08001499 kfree(*hw_fib_p);
1500 kfree(*fib_p);
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001501 ++fib_p;
1502 ++hw_fib_p;
1503 }
Jesper Juhlc9475cb2005-11-07 01:01:26 -08001504 kfree(hw_fib_pool);
1505 kfree(fib_pool);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 kfree(fib);
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001508 spin_lock_irqsave(dev->queues->queue[HostNormCmdQueue].lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 }
1510 /*
1511 * There are no more AIF's
1512 */
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001513 spin_unlock_irqrestore(dev->queues->queue[HostNormCmdQueue].lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 schedule();
1515
Christoph Hellwigfe273812006-02-14 18:45:06 +01001516 if (kthread_should_stop())
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 break;
1518 set_current_state(TASK_INTERRUPTIBLE);
1519 }
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001520 if (dev->queues)
1521 remove_wait_queue(&dev->queues->queue[HostNormCmdQueue].cmdready, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 dev->aif_thread = 0;
Mark Haverkamp2f1309802005-09-26 13:02:15 -07001523 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524}