?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
scsi: aacraid: Fix memory leak in fib init path
[linux-2.6/btrfs-unstable.git] / drivers / scsi / aacraid / commsup.c
blobc10954b3cd46b5763fa7063568ad61f5e0d5c736
1 /*
2 * Adaptec AAC series RAID controller driver
3 * (c) Copyright 2001 Red Hat Inc.
4 *
5 * based on the old aacraid driver that is..
6 * Adaptec aacraid device driver for Linux.
7 *
8 * Copyright (c) 2000-2010 Adaptec, Inc.
9 * 2010-2015 PMC-Sierra, Inc. (aacraid@pmc-sierra.com)
10 * 2016-2017 Microsemi Corp. (aacraid@microsemi.com)
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
15 * any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; see the file COPYING. If not, write to
24 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
25 *
26 * Module Name:
27 * commsup.c
28 *
29 * Abstract: Contain all routines that are required for FSA host/adapter
30 * communication.
31 *
32 */
33
34 #include <linux/kernel.h>
35 #include <linux/init.h>
36 #include <linux/types.h>
37 #include <linux/sched.h>
38 #include <linux/pci.h>
39 #include <linux/spinlock.h>
40 #include <linux/slab.h>
41 #include <linux/completion.h>
42 #include <linux/blkdev.h>
43 #include <linux/delay.h>
44 #include <linux/kthread.h>
45 #include <linux/interrupt.h>
46 #include <linux/semaphore.h>
47 #include <linux/bcd.h>
48 #include <scsi/scsi.h>
49 #include <scsi/scsi_host.h>
50 #include <scsi/scsi_device.h>
51 #include <scsi/scsi_cmnd.h>
52
53 #include "aacraid.h"
54
55 /**
56 * fib_map_alloc - allocate the fib objects
57 * @dev: Adapter to allocate for
58 *
59 * Allocate and map the shared PCI space for the FIB blocks used to
60 * talk to the Adaptec firmware.
61 */
62
63 static int fib_map_alloc(struct aac_dev *dev)
64 {
65 if (dev->max_fib_size > AAC_MAX_NATIVE_SIZE)
66 dev->max_cmd_size = AAC_MAX_NATIVE_SIZE;
67 else
68 dev->max_cmd_size = dev->max_fib_size;
69 if (dev->max_fib_size < AAC_MAX_NATIVE_SIZE) {
70 dev->max_cmd_size = AAC_MAX_NATIVE_SIZE;
71 } else {
72 dev->max_cmd_size = dev->max_fib_size;
73 }
74
75 dprintk((KERN_INFO
76 "allocate hardware fibs pci_alloc_consistent(%p, %d * (%d + %d), %p)\n",
77 dev->pdev, dev->max_cmd_size, dev->scsi_host_ptr->can_queue,
78 AAC_NUM_MGT_FIB, &dev->hw_fib_pa));
79 dev->hw_fib_va = pci_alloc_consistent(dev->pdev,
80 (dev->max_cmd_size + sizeof(struct aac_fib_xporthdr))
81 * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB) + (ALIGN32 - 1),
82 &dev->hw_fib_pa);
83 if (dev->hw_fib_va == NULL)
84 return -ENOMEM;
85 return 0;
86 }
87
88 /**
89 * aac_fib_map_free - free the fib objects
90 * @dev: Adapter to free
91 *
92 * Free the PCI mappings and the memory allocated for FIB blocks
93 * on this adapter.
94 */
95
96 void aac_fib_map_free(struct aac_dev *dev)
97 {
98 size_t alloc_size;
99 size_t fib_size;
100 int num_fibs;
101
102 if(!dev->hw_fib_va || !dev->max_cmd_size)
103 return;
104
105 num_fibs = dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB;
106 fib_size = dev->max_fib_size + sizeof(struct aac_fib_xporthdr);
107 alloc_size = fib_size * num_fibs + ALIGN32 - 1;
108
109 pci_free_consistent(dev->pdev, alloc_size, dev->hw_fib_va,
110 dev->hw_fib_pa);
111
112 dev->hw_fib_va = NULL;
113 dev->hw_fib_pa = 0;
114 }
115
116 void aac_fib_vector_assign(struct aac_dev *dev)
117 {
118 u32 i = 0;
119 u32 vector = 1;
120 struct fib *fibptr = NULL;
121
122 for (i = 0, fibptr = &dev->fibs[i];
123 i < (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB);
124 i++, fibptr++) {
125 if ((dev->max_msix == 1) ||
126 (i > ((dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB - 1)
127 - dev->vector_cap))) {
128 fibptr->vector_no = 0;
129 } else {
130 fibptr->vector_no = vector;
131 vector++;
132 if (vector == dev->max_msix)
133 vector = 1;
134 }
135 }
136 }
137
138 /**
139 * aac_fib_setup - setup the fibs
140 * @dev: Adapter to set up
141 *
142 * Allocate the PCI space for the fibs, map it and then initialise the
143 * fib area, the unmapped fib data and also the free list
144 */
145
146 int aac_fib_setup(struct aac_dev * dev)
147 {
148 struct fib *fibptr;
149 struct hw_fib *hw_fib;
150 dma_addr_t hw_fib_pa;
151 int i;
152 u32 max_cmds;
153
154 while (((i = fib_map_alloc(dev)) == -ENOMEM)
155 && (dev->scsi_host_ptr->can_queue > (64 - AAC_NUM_MGT_FIB))) {
156 max_cmds = (dev->scsi_host_ptr->can_queue+AAC_NUM_MGT_FIB) >> 1;
157 dev->scsi_host_ptr->can_queue = max_cmds - AAC_NUM_MGT_FIB;
158 if (dev->comm_interface != AAC_COMM_MESSAGE_TYPE3)
159 dev->init->r7.max_io_commands = cpu_to_le32(max_cmds);
160 }
161 if (i<0)
162 return -ENOMEM;
163
164 memset(dev->hw_fib_va, 0,
165 (dev->max_cmd_size + sizeof(struct aac_fib_xporthdr)) *
166 (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB));
167
168 /* 32 byte alignment for PMC */
169 hw_fib_pa = (dev->hw_fib_pa + (ALIGN32 - 1)) & ~(ALIGN32 - 1);
170 hw_fib = (struct hw_fib *)((unsigned char *)dev->hw_fib_va +
171 (hw_fib_pa - dev->hw_fib_pa));
172
173 /* add Xport header */
174 hw_fib = (struct hw_fib *)((unsigned char *)hw_fib +
175 sizeof(struct aac_fib_xporthdr));
176 hw_fib_pa += sizeof(struct aac_fib_xporthdr);
177
178 /*
179 * Initialise the fibs
180 */
181 for (i = 0, fibptr = &dev->fibs[i];
182 i < (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB);
183 i++, fibptr++)
184 {
185 fibptr->flags = 0;
186 fibptr->size = sizeof(struct fib);
187 fibptr->dev = dev;
188 fibptr->hw_fib_va = hw_fib;
189 fibptr->data = (void *) fibptr->hw_fib_va->data;
190 fibptr->next = fibptr+1; /* Forward chain the fibs */
191 sema_init(&fibptr->event_wait, 0);
192 spin_lock_init(&fibptr->event_lock);
193 hw_fib->header.XferState = cpu_to_le32(0xffffffff);
194 hw_fib->header.SenderSize =
195 cpu_to_le16(dev->max_fib_size); /* ?? max_cmd_size */
196 fibptr->hw_fib_pa = hw_fib_pa;
197 fibptr->hw_sgl_pa = hw_fib_pa +
198 offsetof(struct aac_hba_cmd_req, sge[2]);
199 /*
200 * one element is for the ptr to the separate sg list,
201 * second element for 32 byte alignment
202 */
203 fibptr->hw_error_pa = hw_fib_pa +
204 offsetof(struct aac_native_hba, resp.resp_bytes[0]);
205
206 hw_fib = (struct hw_fib *)((unsigned char *)hw_fib +
207 dev->max_cmd_size + sizeof(struct aac_fib_xporthdr));
208 hw_fib_pa = hw_fib_pa +
209 dev->max_cmd_size + sizeof(struct aac_fib_xporthdr);
210 }
211
212 /*
213 *Assign vector numbers to fibs
214 */
215 aac_fib_vector_assign(dev);
216
217 /*
218 * Add the fib chain to the free list
219 */
220 dev->fibs[dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB - 1].next = NULL;
221 /*
222 * Set 8 fibs aside for management tools
223 */
224 dev->free_fib = &dev->fibs[dev->scsi_host_ptr->can_queue];
225 return 0;
226 }
227
228 /**
229 * aac_fib_alloc_tag-allocate a fib using tags
230 * @dev: Adapter to allocate the fib for
231 *
232 * Allocate a fib from the adapter fib pool using tags
233 * from the blk layer.
234 */
235
236 struct fib *aac_fib_alloc_tag(struct aac_dev *dev, struct scsi_cmnd *scmd)
237 {
238 struct fib *fibptr;
239
240 fibptr = &dev->fibs[scmd->request->tag];
241 /*
242 * Null out fields that depend on being zero at the start of
243 * each I/O
244 */
245 fibptr->hw_fib_va->header.XferState = 0;
246 fibptr->type = FSAFS_NTC_FIB_CONTEXT;
247 fibptr->callback_data = NULL;
248 fibptr->callback = NULL;
249
250 return fibptr;
251 }
252
253 /**
254 * aac_fib_alloc - allocate a fib
255 * @dev: Adapter to allocate the fib for
256 *
257 * Allocate a fib from the adapter fib pool. If the pool is empty we
258 * return NULL.
259 */
260
261 struct fib *aac_fib_alloc(struct aac_dev *dev)
262 {
263 struct fib * fibptr;
264 unsigned long flags;
265 spin_lock_irqsave(&dev->fib_lock, flags);
266 fibptr = dev->free_fib;
267 if(!fibptr){
268 spin_unlock_irqrestore(&dev->fib_lock, flags);
269 return fibptr;
270 }
271 dev->free_fib = fibptr->next;
272 spin_unlock_irqrestore(&dev->fib_lock, flags);
273 /*
274 * Set the proper node type code and node byte size
275 */
276 fibptr->type = FSAFS_NTC_FIB_CONTEXT;
277 fibptr->size = sizeof(struct fib);
278 /*
279 * Null out fields that depend on being zero at the start of
280 * each I/O
281 */
282 fibptr->hw_fib_va->header.XferState = 0;
283 fibptr->flags = 0;
284 fibptr->callback = NULL;
285 fibptr->callback_data = NULL;
286
287 return fibptr;
288 }
289
290 /**
291 * aac_fib_free - free a fib
292 * @fibptr: fib to free up
293 *
294 * Frees up a fib and places it on the appropriate queue
295 */
296
297 void aac_fib_free(struct fib *fibptr)
298 {
299 unsigned long flags;
300
301 if (fibptr->done == 2)
302 return;
303
304 spin_lock_irqsave(&fibptr->dev->fib_lock, flags);
305 if (unlikely(fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT))
306 aac_config.fib_timeouts++;
307 if (!(fibptr->flags & FIB_CONTEXT_FLAG_NATIVE_HBA) &&
308 fibptr->hw_fib_va->header.XferState != 0) {
309 printk(KERN_WARNING "aac_fib_free, XferState != 0, fibptr = 0x%p, XferState = 0x%x\n",
310 (void*)fibptr,
311 le32_to_cpu(fibptr->hw_fib_va->header.XferState));
312 }
313 fibptr->next = fibptr->dev->free_fib;
314 fibptr->dev->free_fib = fibptr;
315 spin_unlock_irqrestore(&fibptr->dev->fib_lock, flags);
316 }
317
318 /**
319 * aac_fib_init - initialise a fib
320 * @fibptr: The fib to initialize
321 *
322 * Set up the generic fib fields ready for use
323 */
324
325 void aac_fib_init(struct fib *fibptr)
326 {
327 struct hw_fib *hw_fib = fibptr->hw_fib_va;
328
329 memset(&hw_fib->header, 0, sizeof(struct aac_fibhdr));
330 hw_fib->header.StructType = FIB_MAGIC;
331 hw_fib->header.Size = cpu_to_le16(fibptr->dev->max_fib_size);
332 hw_fib->header.XferState = cpu_to_le32(HostOwned | FibInitialized | FibEmpty | FastResponseCapable);
333 hw_fib->header.u.ReceiverFibAddress = cpu_to_le32(fibptr->hw_fib_pa);
334 hw_fib->header.SenderSize = cpu_to_le16(fibptr->dev->max_fib_size);
335 }
336
337 /**
338 * fib_deallocate - deallocate a fib
339 * @fibptr: fib to deallocate
340 *
341 * Will deallocate and return to the free pool the FIB pointed to by the
342 * caller.
343 */
344
345 static void fib_dealloc(struct fib * fibptr)
346 {
347 struct hw_fib *hw_fib = fibptr->hw_fib_va;
348 hw_fib->header.XferState = 0;
349 }
350
351 /*
352 * Commuication primitives define and support the queuing method we use to
353 * support host to adapter commuication. All queue accesses happen through
354 * these routines and are the only routines which have a knowledge of the
355 * how these queues are implemented.
356 */
357
358 /**
359 * aac_get_entry - get a queue entry
360 * @dev: Adapter
361 * @qid: Queue Number
362 * @entry: Entry return
363 * @index: Index return
364 * @nonotify: notification control
365 *
366 * With a priority the routine returns a queue entry if the queue has free entries. If the queue
367 * is full(no free entries) than no entry is returned and the function returns 0 otherwise 1 is
368 * returned.
369 */
370
371 static int aac_get_entry (struct aac_dev * dev, u32 qid, struct aac_entry **entry, u32 * index, unsigned long *nonotify)
372 {
373 struct aac_queue * q;
374 unsigned long idx;
375
376 /*
377 * All of the queues wrap when they reach the end, so we check
378 * to see if they have reached the end and if they have we just
379 * set the index back to zero. This is a wrap. You could or off
380 * the high bits in all updates but this is a bit faster I think.
381 */
382
383 q = &dev->queues->queue[qid];
384
385 idx = *index = le32_to_cpu(*(q->headers.producer));
386 /* Interrupt Moderation, only interrupt for first two entries */
387 if (idx != le32_to_cpu(*(q->headers.consumer))) {
388 if (--idx == 0) {
389 if (qid == AdapNormCmdQueue)
390 idx = ADAP_NORM_CMD_ENTRIES;
391 else
392 idx = ADAP_NORM_RESP_ENTRIES;
393 }
394 if (idx != le32_to_cpu(*(q->headers.consumer)))
395 *nonotify = 1;
396 }
397
398 if (qid == AdapNormCmdQueue) {
399 if (*index >= ADAP_NORM_CMD_ENTRIES)
400 *index = 0; /* Wrap to front of the Producer Queue. */
401 } else {
402 if (*index >= ADAP_NORM_RESP_ENTRIES)
403 *index = 0; /* Wrap to front of the Producer Queue. */
404 }
405
406 /* Queue is full */
407 if ((*index + 1) == le32_to_cpu(*(q->headers.consumer))) {
408 printk(KERN_WARNING "Queue %d full, %u outstanding.\n",
409 qid, atomic_read(&q->numpending));
410 return 0;
411 } else {
412 *entry = q->base + *index;
413 return 1;
414 }
415 }
416
417 /**
418 * aac_queue_get - get the next free QE
419 * @dev: Adapter
420 * @index: Returned index
421 * @priority: Priority of fib
422 * @fib: Fib to associate with the queue entry
423 * @wait: Wait if queue full
424 * @fibptr: Driver fib object to go with fib
425 * @nonotify: Don't notify the adapter
426 *
427 * Gets the next free QE off the requested priorty adapter command
428 * queue and associates the Fib with the QE. The QE represented by
429 * index is ready to insert on the queue when this routine returns
430 * success.
431 */
432
433 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)
434 {
435 struct aac_entry * entry = NULL;
436 int map = 0;
437
438 if (qid == AdapNormCmdQueue) {
439 /* if no entries wait for some if caller wants to */
440 while (!aac_get_entry(dev, qid, &entry, index, nonotify)) {
441 printk(KERN_ERR "GetEntries failed\n");
442 }
443 /*
444 * Setup queue entry with a command, status and fib mapped
445 */
446 entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size));
447 map = 1;
448 } else {
449 while (!aac_get_entry(dev, qid, &entry, index, nonotify)) {
450 /* if no entries wait for some if caller wants to */
451 }
452 /*
453 * Setup queue entry with command, status and fib mapped
454 */
455 entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size));
456 entry->addr = hw_fib->header.SenderFibAddress;
457 /* Restore adapters pointer to the FIB */
458 hw_fib->header.u.ReceiverFibAddress = hw_fib->header.SenderFibAddress; /* Let the adapter now where to find its data */
459 map = 0;
460 }
461 /*
462 * If MapFib is true than we need to map the Fib and put pointers
463 * in the queue entry.
464 */
465 if (map)
466 entry->addr = cpu_to_le32(fibptr->hw_fib_pa);
467 return 0;
468 }
469
470 #ifdef CONFIG_EEH
471 static inline int aac_check_eeh_failure(struct aac_dev *dev)
472 {
473 /* Check for an EEH failure for the given
474 * device node. Function eeh_dev_check_failure()
475 * returns 0 if there has not been an EEH error
476 * otherwise returns a non-zero value.
477 *
478 * Need to be called before any PCI operation,
479 * i.e.,before aac_adapter_check_health()
480 */
481 struct eeh_dev *edev = pci_dev_to_eeh_dev(dev->pdev);
482
483 if (eeh_dev_check_failure(edev)) {
484 /* The EEH mechanisms will handle this
485 * error and reset the device if
486 * necessary.
487 */
488 return 1;
489 }
490 return 0;
491 }
492 #else
493 static inline int aac_check_eeh_failure(struct aac_dev *dev)
494 {
495 return 0;
496 }
497 #endif
498
499 /*
500 * Define the highest level of host to adapter communication routines.
501 * These routines will support host to adapter FS commuication. These
502 * routines have no knowledge of the commuication method used. This level
503 * sends and receives FIBs. This level has no knowledge of how these FIBs
504 * get passed back and forth.
505 */
506
507 /**
508 * aac_fib_send - send a fib to the adapter
509 * @command: Command to send
510 * @fibptr: The fib
511 * @size: Size of fib data area
512 * @priority: Priority of Fib
513 * @wait: Async/sync select
514 * @reply: True if a reply is wanted
515 * @callback: Called with reply
516 * @callback_data: Passed to callback
517 *
518 * Sends the requested FIB to the adapter and optionally will wait for a
519 * response FIB. If the caller does not wish to wait for a response than
520 * an event to wait on must be supplied. This event will be set when a
521 * response FIB is received from the adapter.
522 */
523
524 int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
525 int priority, int wait, int reply, fib_callback callback,
526 void *callback_data)
527 {
528 struct aac_dev * dev = fibptr->dev;
529 struct hw_fib * hw_fib = fibptr->hw_fib_va;
530 unsigned long flags = 0;
531 unsigned long mflags = 0;
532 unsigned long sflags = 0;
533
534 if (!(hw_fib->header.XferState & cpu_to_le32(HostOwned)))
535 return -EBUSY;
536
537 if (hw_fib->header.XferState & cpu_to_le32(AdapterProcessed))
538 return -EINVAL;
539
540 /*
541 * There are 5 cases with the wait and response requested flags.
542 * The only invalid cases are if the caller requests to wait and
543 * does not request a response and if the caller does not want a
544 * response and the Fib is not allocated from pool. If a response
545 * is not requesed the Fib will just be deallocaed by the DPC
546 * routine when the response comes back from the adapter. No
547 * further processing will be done besides deleting the Fib. We
548 * will have a debug mode where the adapter can notify the host
549 * it had a problem and the host can log that fact.
550 */
551 fibptr->flags = 0;
552 if (wait && !reply) {
553 return -EINVAL;
554 } else if (!wait && reply) {
555 hw_fib->header.XferState |= cpu_to_le32(Async | ResponseExpected);
556 FIB_COUNTER_INCREMENT(aac_config.AsyncSent);
557 } else if (!wait && !reply) {
558 hw_fib->header.XferState |= cpu_to_le32(NoResponseExpected);
559 FIB_COUNTER_INCREMENT(aac_config.NoResponseSent);
560 } else if (wait && reply) {
561 hw_fib->header.XferState |= cpu_to_le32(ResponseExpected);
562 FIB_COUNTER_INCREMENT(aac_config.NormalSent);
563 }
564 /*
565 * Map the fib into 32bits by using the fib number
566 */
567
568 hw_fib->header.SenderFibAddress =
569 cpu_to_le32(((u32)(fibptr - dev->fibs)) << 2);
570
571 /* use the same shifted value for handle to be compatible
572 * with the new native hba command handle
573 */
574 hw_fib->header.Handle =
575 cpu_to_le32((((u32)(fibptr - dev->fibs)) << 2) + 1);
576
577 /*
578 * Set FIB state to indicate where it came from and if we want a
579 * response from the adapter. Also load the command from the
580 * caller.
581 *
582 * Map the hw fib pointer as a 32bit value
583 */
584 hw_fib->header.Command = cpu_to_le16(command);
585 hw_fib->header.XferState |= cpu_to_le32(SentFromHost);
586 /*
587 * Set the size of the Fib we want to send to the adapter
588 */
589 hw_fib->header.Size = cpu_to_le16(sizeof(struct aac_fibhdr) + size);
590 if (le16_to_cpu(hw_fib->header.Size) > le16_to_cpu(hw_fib->header.SenderSize)) {
591 return -EMSGSIZE;
592 }
593 /*
594 * Get a queue entry connect the FIB to it and send an notify
595 * the adapter a command is ready.
596 */
597 hw_fib->header.XferState |= cpu_to_le32(NormalPriority);
598
599 /*
600 * Fill in the Callback and CallbackContext if we are not
601 * going to wait.
602 */
603 if (!wait) {
604 fibptr->callback = callback;
605 fibptr->callback_data = callback_data;
606 fibptr->flags = FIB_CONTEXT_FLAG;
607 }
608
609 fibptr->done = 0;
610
611 FIB_COUNTER_INCREMENT(aac_config.FibsSent);
612
613 dprintk((KERN_DEBUG "Fib contents:.\n"));
614 dprintk((KERN_DEBUG " Command = %d.\n", le32_to_cpu(hw_fib->header.Command)));
615 dprintk((KERN_DEBUG " SubCommand = %d.\n", le32_to_cpu(((struct aac_query_mount *)fib_data(fibptr))->command)));
616 dprintk((KERN_DEBUG " XferState = %x.\n", le32_to_cpu(hw_fib->header.XferState)));
617 dprintk((KERN_DEBUG " hw_fib va being sent=%p\n",fibptr->hw_fib_va));
618 dprintk((KERN_DEBUG " hw_fib pa being sent=%lx\n",(ulong)fibptr->hw_fib_pa));
619 dprintk((KERN_DEBUG " fib being sent=%p\n",fibptr));
620
621 if (!dev->queues)
622 return -EBUSY;
623
624 if (wait) {
625
626 spin_lock_irqsave(&dev->manage_lock, mflags);
627 if (dev->management_fib_count >= AAC_NUM_MGT_FIB) {
628 printk(KERN_INFO "No management Fibs Available:%d\n",
629 dev->management_fib_count);
630 spin_unlock_irqrestore(&dev->manage_lock, mflags);
631 return -EBUSY;
632 }
633 dev->management_fib_count++;
634 spin_unlock_irqrestore(&dev->manage_lock, mflags);
635 spin_lock_irqsave(&fibptr->event_lock, flags);
636 }
637
638 if (dev->sync_mode) {
639 if (wait)
640 spin_unlock_irqrestore(&fibptr->event_lock, flags);
641 spin_lock_irqsave(&dev->sync_lock, sflags);
642 if (dev->sync_fib) {
643 list_add_tail(&fibptr->fiblink, &dev->sync_fib_list);
644 spin_unlock_irqrestore(&dev->sync_lock, sflags);
645 } else {
646 dev->sync_fib = fibptr;
647 spin_unlock_irqrestore(&dev->sync_lock, sflags);
648 aac_adapter_sync_cmd(dev, SEND_SYNCHRONOUS_FIB,
649 (u32)fibptr->hw_fib_pa, 0, 0, 0, 0, 0,
650 NULL, NULL, NULL, NULL, NULL);
651 }
652 if (wait) {
653 fibptr->flags |= FIB_CONTEXT_FLAG_WAIT;
654 if (down_interruptible(&fibptr->event_wait)) {
655 fibptr->flags &= ~FIB_CONTEXT_FLAG_WAIT;
656 return -EFAULT;
657 }
658 return 0;
659 }
660 return -EINPROGRESS;
661 }
662
663 if (aac_adapter_deliver(fibptr) != 0) {
664 printk(KERN_ERR "aac_fib_send: returned -EBUSY\n");
665 if (wait) {
666 spin_unlock_irqrestore(&fibptr->event_lock, flags);
667 spin_lock_irqsave(&dev->manage_lock, mflags);
668 dev->management_fib_count--;
669 spin_unlock_irqrestore(&dev->manage_lock, mflags);
670 }
671 return -EBUSY;
672 }
673
674
675 /*
676 * If the caller wanted us to wait for response wait now.
677 */
678
679 if (wait) {
680 spin_unlock_irqrestore(&fibptr->event_lock, flags);
681 /* Only set for first known interruptable command */
682 if (wait < 0) {
683 /*
684 * *VERY* Dangerous to time out a command, the
685 * assumption is made that we have no hope of
686 * functioning because an interrupt routing or other
687 * hardware failure has occurred.
688 */
689 unsigned long timeout = jiffies + (180 * HZ); /* 3 minutes */
690 while (down_trylock(&fibptr->event_wait)) {
691 int blink;
692 if (time_is_before_eq_jiffies(timeout)) {
693 struct aac_queue * q = &dev->queues->queue[AdapNormCmdQueue];
694 atomic_dec(&q->numpending);
695 if (wait == -1) {
696 printk(KERN_ERR "aacraid: aac_fib_send: first asynchronous command timed out.\n"
697 "Usually a result of a PCI interrupt routing problem;\n"
698 "update mother board BIOS or consider utilizing one of\n"
699 "the SAFE mode kernel options (acpi, apic etc)\n");
700 }
701 return -ETIMEDOUT;
702 }
703
704 if (aac_check_eeh_failure(dev))
705 return -EFAULT;
706
707 if ((blink = aac_adapter_check_health(dev)) > 0) {
708 if (wait == -1) {
709 printk(KERN_ERR "aacraid: aac_fib_send: adapter blinkLED 0x%x.\n"
710 "Usually a result of a serious unrecoverable hardware problem\n",
711 blink);
712 }
713 return -EFAULT;
714 }
715 /*
716 * Allow other processes / CPUS to use core
717 */
718 schedule();
719 }
720 } else if (down_interruptible(&fibptr->event_wait)) {
721 /* Do nothing ... satisfy
722 * down_interruptible must_check */
723 }
724
725 spin_lock_irqsave(&fibptr->event_lock, flags);
726 if (fibptr->done == 0) {
727 fibptr->done = 2; /* Tell interrupt we aborted */
728 spin_unlock_irqrestore(&fibptr->event_lock, flags);
729 return -ERESTARTSYS;
730 }
731 spin_unlock_irqrestore(&fibptr->event_lock, flags);
732 BUG_ON(fibptr->done == 0);
733
734 if(unlikely(fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT))
735 return -ETIMEDOUT;
736 return 0;
737 }
738 /*
739 * If the user does not want a response than return success otherwise
740 * return pending
741 */
742 if (reply)
743 return -EINPROGRESS;
744 else
745 return 0;
746 }
747
748 int aac_hba_send(u8 command, struct fib *fibptr, fib_callback callback,
749 void *callback_data)
750 {
751 struct aac_dev *dev = fibptr->dev;
752 int wait;
753 unsigned long flags = 0;
754 unsigned long mflags = 0;
755
756 fibptr->flags = (FIB_CONTEXT_FLAG | FIB_CONTEXT_FLAG_NATIVE_HBA);
757 if (callback) {
758 wait = 0;
759 fibptr->callback = callback;
760 fibptr->callback_data = callback_data;
761 } else
762 wait = 1;
763
764
765 if (command == HBA_IU_TYPE_SCSI_CMD_REQ) {
766 struct aac_hba_cmd_req *hbacmd =
767 (struct aac_hba_cmd_req *)fibptr->hw_fib_va;
768
769 hbacmd->iu_type = command;
770 /* bit1 of request_id must be 0 */
771 hbacmd->request_id =
772 cpu_to_le32((((u32)(fibptr - dev->fibs)) << 2) + 1);
773 } else
774 return -EINVAL;
775
776
777 if (wait) {
778 spin_lock_irqsave(&dev->manage_lock, mflags);
779 if (dev->management_fib_count >= AAC_NUM_MGT_FIB) {
780 spin_unlock_irqrestore(&dev->manage_lock, mflags);
781 return -EBUSY;
782 }
783 dev->management_fib_count++;
784 spin_unlock_irqrestore(&dev->manage_lock, mflags);
785 spin_lock_irqsave(&fibptr->event_lock, flags);
786 }
787
788 if (aac_adapter_deliver(fibptr) != 0) {
789 if (wait) {
790 spin_unlock_irqrestore(&fibptr->event_lock, flags);
791 spin_lock_irqsave(&dev->manage_lock, mflags);
792 dev->management_fib_count--;
793 spin_unlock_irqrestore(&dev->manage_lock, mflags);
794 }
795 return -EBUSY;
796 }
797 FIB_COUNTER_INCREMENT(aac_config.NativeSent);
798
799 if (wait) {
800
801 spin_unlock_irqrestore(&fibptr->event_lock, flags);
802
803 if (aac_check_eeh_failure(dev))
804 return -EFAULT;
805
806 /* Only set for first known interruptable command */
807 if (down_interruptible(&fibptr->event_wait)) {
808 fibptr->done = 2;
809 up(&fibptr->event_wait);
810 }
811 spin_lock_irqsave(&fibptr->event_lock, flags);
812 if ((fibptr->done == 0) || (fibptr->done == 2)) {
813 fibptr->done = 2; /* Tell interrupt we aborted */
814 spin_unlock_irqrestore(&fibptr->event_lock, flags);
815 return -ERESTARTSYS;
816 }
817 spin_unlock_irqrestore(&fibptr->event_lock, flags);
818 WARN_ON(fibptr->done == 0);
819
820 if (unlikely(fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT))
821 return -ETIMEDOUT;
822
823 return 0;
824 }
825
826 return -EINPROGRESS;
827 }
828
829 /**
830 * aac_consumer_get - get the top of the queue
831 * @dev: Adapter
832 * @q: Queue
833 * @entry: Return entry
834 *
835 * Will return a pointer to the entry on the top of the queue requested that
836 * we are a consumer of, and return the address of the queue entry. It does
837 * not change the state of the queue.
838 */
839
840 int aac_consumer_get(struct aac_dev * dev, struct aac_queue * q, struct aac_entry **entry)
841 {
842 u32 index;
843 int status;
844 if (le32_to_cpu(*q->headers.producer) == le32_to_cpu(*q->headers.consumer)) {
845 status = 0;
846 } else {
847 /*
848 * The consumer index must be wrapped if we have reached
849 * the end of the queue, else we just use the entry
850 * pointed to by the header index
851 */
852 if (le32_to_cpu(*q->headers.consumer) >= q->entries)
853 index = 0;
854 else
855 index = le32_to_cpu(*q->headers.consumer);
856 *entry = q->base + index;
857 status = 1;
858 }
859 return(status);
860 }
861
862 /**
863 * aac_consumer_free - free consumer entry
864 * @dev: Adapter
865 * @q: Queue
866 * @qid: Queue ident
867 *
868 * Frees up the current top of the queue we are a consumer of. If the
869 * queue was full notify the producer that the queue is no longer full.
870 */
871
872 void aac_consumer_free(struct aac_dev * dev, struct aac_queue *q, u32 qid)
873 {
874 int wasfull = 0;
875 u32 notify;
876
877 if ((le32_to_cpu(*q->headers.producer)+1) == le32_to_cpu(*q->headers.consumer))
878 wasfull = 1;
879
880 if (le32_to_cpu(*q->headers.consumer) >= q->entries)
881 *q->headers.consumer = cpu_to_le32(1);
882 else
883 le32_add_cpu(q->headers.consumer, 1);
884
885 if (wasfull) {
886 switch (qid) {
887
888 case HostNormCmdQueue:
889 notify = HostNormCmdNotFull;
890 break;
891 case HostNormRespQueue:
892 notify = HostNormRespNotFull;
893 break;
894 default:
895 BUG();
896 return;
897 }
898 aac_adapter_notify(dev, notify);
899 }
900 }
901
902 /**
903 * aac_fib_adapter_complete - complete adapter issued fib
904 * @fibptr: fib to complete
905 * @size: size of fib
906 *
907 * Will do all necessary work to complete a FIB that was sent from
908 * the adapter.
909 */
910
911 int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size)
912 {
913 struct hw_fib * hw_fib = fibptr->hw_fib_va;
914 struct aac_dev * dev = fibptr->dev;
915 struct aac_queue * q;
916 unsigned long nointr = 0;
917 unsigned long qflags;
918
919 if (dev->comm_interface == AAC_COMM_MESSAGE_TYPE1 ||
920 dev->comm_interface == AAC_COMM_MESSAGE_TYPE2 ||
921 dev->comm_interface == AAC_COMM_MESSAGE_TYPE3) {
922 kfree(hw_fib);
923 return 0;
924 }
925
926 if (hw_fib->header.XferState == 0) {
927 if (dev->comm_interface == AAC_COMM_MESSAGE)
928 kfree(hw_fib);
929 return 0;
930 }
931 /*
932 * If we plan to do anything check the structure type first.
933 */
934 if (hw_fib->header.StructType != FIB_MAGIC &&
935 hw_fib->header.StructType != FIB_MAGIC2 &&
936 hw_fib->header.StructType != FIB_MAGIC2_64) {
937 if (dev->comm_interface == AAC_COMM_MESSAGE)
938 kfree(hw_fib);
939 return -EINVAL;
940 }
941 /*
942 * This block handles the case where the adapter had sent us a
943 * command and we have finished processing the command. We
944 * call completeFib when we are done processing the command
945 * and want to send a response back to the adapter. This will
946 * send the completed cdb to the adapter.
947 */
948 if (hw_fib->header.XferState & cpu_to_le32(SentFromAdapter)) {
949 if (dev->comm_interface == AAC_COMM_MESSAGE) {
950 kfree (hw_fib);
951 } else {
952 u32 index;
953 hw_fib->header.XferState |= cpu_to_le32(HostProcessed);
954 if (size) {
955 size += sizeof(struct aac_fibhdr);
956 if (size > le16_to_cpu(hw_fib->header.SenderSize))
957 return -EMSGSIZE;
958 hw_fib->header.Size = cpu_to_le16(size);
959 }
960 q = &dev->queues->queue[AdapNormRespQueue];
961 spin_lock_irqsave(q->lock, qflags);
962 aac_queue_get(dev, &index, AdapNormRespQueue, hw_fib, 1, NULL, &nointr);
963 *(q->headers.producer) = cpu_to_le32(index + 1);
964 spin_unlock_irqrestore(q->lock, qflags);
965 if (!(nointr & (int)aac_config.irq_mod))
966 aac_adapter_notify(dev, AdapNormRespQueue);
967 }
968 } else {
969 printk(KERN_WARNING "aac_fib_adapter_complete: "
970 "Unknown xferstate detected.\n");
971 BUG();
972 }
973 return 0;
974 }
975
976 /**
977 * aac_fib_complete - fib completion handler
978 * @fib: FIB to complete
979 *
980 * Will do all necessary work to complete a FIB.
981 */
982
983 int aac_fib_complete(struct fib *fibptr)
984 {
985 struct hw_fib * hw_fib = fibptr->hw_fib_va;
986
987 if (fibptr->flags & FIB_CONTEXT_FLAG_NATIVE_HBA) {
988 fib_dealloc(fibptr);
989 return 0;
990 }
991
992 /*
993 * Check for a fib which has already been completed or with a
994 * status wait timeout
995 */
996
997 if (hw_fib->header.XferState == 0 || fibptr->done == 2)
998 return 0;
999 /*
1000 * If we plan to do anything check the structure type first.
1001 */
1002
1003 if (hw_fib->header.StructType != FIB_MAGIC &&
1004 hw_fib->header.StructType != FIB_MAGIC2 &&
1005 hw_fib->header.StructType != FIB_MAGIC2_64)
1006 return -EINVAL;
1007 /*
1008 * This block completes a cdb which orginated on the host and we
1009 * just need to deallocate the cdb or reinit it. At this point the
1010 * command is complete that we had sent to the adapter and this
1011 * cdb could be reused.
1012 */
1013
1014 if((hw_fib->header.XferState & cpu_to_le32(SentFromHost)) &&
1015 (hw_fib->header.XferState & cpu_to_le32(AdapterProcessed)))
1016 {
1017 fib_dealloc(fibptr);
1018 }
1019 else if(hw_fib->header.XferState & cpu_to_le32(SentFromHost))
1020 {
1021 /*
1022 * This handles the case when the host has aborted the I/O
1023 * to the adapter because the adapter is not responding
1024 */
1025 fib_dealloc(fibptr);
1026 } else if(hw_fib->header.XferState & cpu_to_le32(HostOwned)) {
1027 fib_dealloc(fibptr);
1028 } else {
1029 BUG();
1030 }
1031 return 0;
1032 }
1033
1034 /**
1035 * aac_printf - handle printf from firmware
1036 * @dev: Adapter
1037 * @val: Message info
1038 *
1039 * Print a message passed to us by the controller firmware on the
1040 * Adaptec board
1041 */
1042
1043 void aac_printf(struct aac_dev *dev, u32 val)
1044 {
1045 char *cp = dev->printfbuf;
1046 if (dev->printf_enabled)
1047 {
1048 int length = val & 0xffff;
1049 int level = (val >> 16) & 0xffff;
1050
1051 /*
1052 * The size of the printfbuf is set in port.c
1053 * There is no variable or define for it
1054 */
1055 if (length > 255)
1056 length = 255;
1057 if (cp[length] != 0)
1058 cp[length] = 0;
1059 if (level == LOG_AAC_HIGH_ERROR)
1060 printk(KERN_WARNING "%s:%s", dev->name, cp);
1061 else
1062 printk(KERN_INFO "%s:%s", dev->name, cp);
1063 }
1064 memset(cp, 0, 256);
1065 }
1066
1067 static inline int aac_aif_data(struct aac_aifcmd *aifcmd, uint32_t index)
1068 {
1069 return le32_to_cpu(((__le32 *)aifcmd->data)[index]);
1070 }
1071
1072
1073 static void aac_handle_aif_bu(struct aac_dev *dev, struct aac_aifcmd *aifcmd)
1074 {
1075 switch (aac_aif_data(aifcmd, 1)) {
1076 case AifBuCacheDataLoss:
1077 if (aac_aif_data(aifcmd, 2))
1078 dev_info(&dev->pdev->dev, "Backup unit had cache data loss - [%d]\n",
1079 aac_aif_data(aifcmd, 2));
1080 else
1081 dev_info(&dev->pdev->dev, "Backup Unit had cache data loss\n");
1082 break;
1083 case AifBuCacheDataRecover:
1084 if (aac_aif_data(aifcmd, 2))
1085 dev_info(&dev->pdev->dev, "DDR cache data recovered successfully - [%d]\n",
1086 aac_aif_data(aifcmd, 2));
1087 else
1088 dev_info(&dev->pdev->dev, "DDR cache data recovered successfully\n");
1089 break;
1090 }
1091 }
1092
1093 /**
1094 * aac_handle_aif - Handle a message from the firmware
1095 * @dev: Which adapter this fib is from
1096 * @fibptr: Pointer to fibptr from adapter
1097 *
1098 * This routine handles a driver notify fib from the adapter and
1099 * dispatches it to the appropriate routine for handling.
1100 */
1101
1102 #define AIF_SNIFF_TIMEOUT (500*HZ)
1103 static void aac_handle_aif(struct aac_dev * dev, struct fib * fibptr)
1104 {
1105 struct hw_fib * hw_fib = fibptr->hw_fib_va;
1106 struct aac_aifcmd * aifcmd = (struct aac_aifcmd *)hw_fib->data;
1107 u32 channel, id, lun, container;
1108 struct scsi_device *device;
1109 enum {
1110 NOTHING,
1111 DELETE,
1112 ADD,
1113 CHANGE
1114 } device_config_needed = NOTHING;
1115
1116 /* Sniff for container changes */
1117
1118 if (!dev || !dev->fsa_dev)
1119 return;
1120 container = channel = id = lun = (u32)-1;
1121
1122 /*
1123 * We have set this up to try and minimize the number of
1124 * re-configures that take place. As a result of this when
1125 * certain AIF's come in we will set a flag waiting for another
1126 * type of AIF before setting the re-config flag.
1127 */
1128 switch (le32_to_cpu(aifcmd->command)) {
1129 case AifCmdDriverNotify:
1130 switch (le32_to_cpu(((__le32 *)aifcmd->data)[0])) {
1131 case AifRawDeviceRemove:
1132 container = le32_to_cpu(((__le32 *)aifcmd->data)[1]);
1133 if ((container >> 28)) {
1134 container = (u32)-1;
1135 break;
1136 }
1137 channel = (container >> 24) & 0xF;
1138 if (channel >= dev->maximum_num_channels) {
1139 container = (u32)-1;
1140 break;
1141 }
1142 id = container & 0xFFFF;
1143 if (id >= dev->maximum_num_physicals) {
1144 container = (u32)-1;
1145 break;
1146 }
1147 lun = (container >> 16) & 0xFF;
1148 container = (u32)-1;
1149 channel = aac_phys_to_logical(channel);
1150 device_config_needed = DELETE;
1151 break;
1152
1153 /*
1154 * Morph or Expand complete
1155 */
1156 case AifDenMorphComplete:
1157 case AifDenVolumeExtendComplete:
1158 container = le32_to_cpu(((__le32 *)aifcmd->data)[1]);
1159 if (container >= dev->maximum_num_containers)
1160 break;
1161
1162 /*
1163 * Find the scsi_device associated with the SCSI
1164 * address. Make sure we have the right array, and if
1165 * so set the flag to initiate a new re-config once we
1166 * see an AifEnConfigChange AIF come through.
1167 */
1168
1169 if ((dev != NULL) && (dev->scsi_host_ptr != NULL)) {
1170 device = scsi_device_lookup(dev->scsi_host_ptr,
1171 CONTAINER_TO_CHANNEL(container),
1172 CONTAINER_TO_ID(container),
1173 CONTAINER_TO_LUN(container));
1174 if (device) {
1175 dev->fsa_dev[container].config_needed = CHANGE;
1176 dev->fsa_dev[container].config_waiting_on = AifEnConfigChange;
1177 dev->fsa_dev[container].config_waiting_stamp = jiffies;
1178 scsi_device_put(device);
1179 }
1180 }
1181 }
1182
1183 /*
1184 * If we are waiting on something and this happens to be
1185 * that thing then set the re-configure flag.
1186 */
1187 if (container != (u32)-1) {
1188 if (container >= dev->maximum_num_containers)
1189 break;
1190 if ((dev->fsa_dev[container].config_waiting_on ==
1191 le32_to_cpu(*(__le32 *)aifcmd->data)) &&
1192 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
1193 dev->fsa_dev[container].config_waiting_on = 0;
1194 } else for (container = 0;
1195 container < dev->maximum_num_containers; ++container) {
1196 if ((dev->fsa_dev[container].config_waiting_on ==
1197 le32_to_cpu(*(__le32 *)aifcmd->data)) &&
1198 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
1199 dev->fsa_dev[container].config_waiting_on = 0;
1200 }
1201 break;
1202
1203 case AifCmdEventNotify:
1204 switch (le32_to_cpu(((__le32 *)aifcmd->data)[0])) {
1205 case AifEnBatteryEvent:
1206 dev->cache_protected =
1207 (((__le32 *)aifcmd->data)[1] == cpu_to_le32(3));
1208 break;
1209 /*
1210 * Add an Array.
1211 */
1212 case AifEnAddContainer:
1213 container = le32_to_cpu(((__le32 *)aifcmd->data)[1]);
1214 if (container >= dev->maximum_num_containers)
1215 break;
1216 dev->fsa_dev[container].config_needed = ADD;
1217 dev->fsa_dev[container].config_waiting_on =
1218 AifEnConfigChange;
1219 dev->fsa_dev[container].config_waiting_stamp = jiffies;
1220 break;
1221
1222 /*
1223 * Delete an Array.
1224 */
1225 case AifEnDeleteContainer:
1226 container = le32_to_cpu(((__le32 *)aifcmd->data)[1]);
1227 if (container >= dev->maximum_num_containers)
1228 break;
1229 dev->fsa_dev[container].config_needed = DELETE;
1230 dev->fsa_dev[container].config_waiting_on =
1231 AifEnConfigChange;
1232 dev->fsa_dev[container].config_waiting_stamp = jiffies;
1233 break;
1234
1235 /*
1236 * Container change detected. If we currently are not
1237 * waiting on something else, setup to wait on a Config Change.
1238 */
1239 case AifEnContainerChange:
1240 container = le32_to_cpu(((__le32 *)aifcmd->data)[1]);
1241 if (container >= dev->maximum_num_containers)
1242 break;
1243 if (dev->fsa_dev[container].config_waiting_on &&
1244 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
1245 break;
1246 dev->fsa_dev[container].config_needed = CHANGE;
1247 dev->fsa_dev[container].config_waiting_on =
1248 AifEnConfigChange;
1249 dev->fsa_dev[container].config_waiting_stamp = jiffies;
1250 break;
1251
1252 case AifEnConfigChange:
1253 break;
1254
1255 case AifEnAddJBOD:
1256 case AifEnDeleteJBOD:
1257 container = le32_to_cpu(((__le32 *)aifcmd->data)[1]);
1258 if ((container >> 28)) {
1259 container = (u32)-1;
1260 break;
1261 }
1262 channel = (container >> 24) & 0xF;
1263 if (channel >= dev->maximum_num_channels) {
1264 container = (u32)-1;
1265 break;
1266 }
1267 id = container & 0xFFFF;
1268 if (id >= dev->maximum_num_physicals) {
1269 container = (u32)-1;
1270 break;
1271 }
1272 lun = (container >> 16) & 0xFF;
1273 container = (u32)-1;
1274 channel = aac_phys_to_logical(channel);
1275 device_config_needed =
1276 (((__le32 *)aifcmd->data)[0] ==
1277 cpu_to_le32(AifEnAddJBOD)) ? ADD : DELETE;
1278 if (device_config_needed == ADD) {
1279 device = scsi_device_lookup(dev->scsi_host_ptr,
1280 channel,
1281 id,
1282 lun);
1283 if (device) {
1284 scsi_remove_device(device);
1285 scsi_device_put(device);
1286 }
1287 }
1288 break;
1289
1290 case AifEnEnclosureManagement:
1291 /*
1292 * If in JBOD mode, automatic exposure of new
1293 * physical target to be suppressed until configured.
1294 */
1295 if (dev->jbod)
1296 break;
1297 switch (le32_to_cpu(((__le32 *)aifcmd->data)[3])) {
1298 case EM_DRIVE_INSERTION:
1299 case EM_DRIVE_REMOVAL:
1300 case EM_SES_DRIVE_INSERTION:
1301 case EM_SES_DRIVE_REMOVAL:
1302 container = le32_to_cpu(
1303 ((__le32 *)aifcmd->data)[2]);
1304 if ((container >> 28)) {
1305 container = (u32)-1;
1306 break;
1307 }
1308 channel = (container >> 24) & 0xF;
1309 if (channel >= dev->maximum_num_channels) {
1310 container = (u32)-1;
1311 break;
1312 }
1313 id = container & 0xFFFF;
1314 lun = (container >> 16) & 0xFF;
1315 container = (u32)-1;
1316 if (id >= dev->maximum_num_physicals) {
1317 /* legacy dev_t ? */
1318 if ((0x2000 <= id) || lun || channel ||
1319 ((channel = (id >> 7) & 0x3F) >=
1320 dev->maximum_num_channels))
1321 break;
1322 lun = (id >> 4) & 7;
1323 id &= 0xF;
1324 }
1325 channel = aac_phys_to_logical(channel);
1326 device_config_needed =
1327 ((((__le32 *)aifcmd->data)[3]
1328 == cpu_to_le32(EM_DRIVE_INSERTION)) ||
1329 (((__le32 *)aifcmd->data)[3]
1330 == cpu_to_le32(EM_SES_DRIVE_INSERTION))) ?
1331 ADD : DELETE;
1332 break;
1333 }
1334 case AifBuManagerEvent:
1335 aac_handle_aif_bu(dev, aifcmd);
1336 break;
1337 }
1338
1339 /*
1340 * If we are waiting on something and this happens to be
1341 * that thing then set the re-configure flag.
1342 */
1343 if (container != (u32)-1) {
1344 if (container >= dev->maximum_num_containers)
1345 break;
1346 if ((dev->fsa_dev[container].config_waiting_on ==
1347 le32_to_cpu(*(__le32 *)aifcmd->data)) &&
1348 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
1349 dev->fsa_dev[container].config_waiting_on = 0;
1350 } else for (container = 0;
1351 container < dev->maximum_num_containers; ++container) {
1352 if ((dev->fsa_dev[container].config_waiting_on ==
1353 le32_to_cpu(*(__le32 *)aifcmd->data)) &&
1354 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT))
1355 dev->fsa_dev[container].config_waiting_on = 0;
1356 }
1357 break;
1358
1359 case AifCmdJobProgress:
1360 /*
1361 * These are job progress AIF's. When a Clear is being
1362 * done on a container it is initially created then hidden from
1363 * the OS. When the clear completes we don't get a config
1364 * change so we monitor the job status complete on a clear then
1365 * wait for a container change.
1366 */
1367
1368 if (((__le32 *)aifcmd->data)[1] == cpu_to_le32(AifJobCtrZero) &&
1369 (((__le32 *)aifcmd->data)[6] == ((__le32 *)aifcmd->data)[5] ||
1370 ((__le32 *)aifcmd->data)[4] == cpu_to_le32(AifJobStsSuccess))) {
1371 for (container = 0;
1372 container < dev->maximum_num_containers;
1373 ++container) {
1374 /*
1375 * Stomp on all config sequencing for all
1376 * containers?
1377 */
1378 dev->fsa_dev[container].config_waiting_on =
1379 AifEnContainerChange;
1380 dev->fsa_dev[container].config_needed = ADD;
1381 dev->fsa_dev[container].config_waiting_stamp =
1382 jiffies;
1383 }
1384 }
1385 if (((__le32 *)aifcmd->data)[1] == cpu_to_le32(AifJobCtrZero) &&
1386 ((__le32 *)aifcmd->data)[6] == 0 &&
1387 ((__le32 *)aifcmd->data)[4] == cpu_to_le32(AifJobStsRunning)) {
1388 for (container = 0;
1389 container < dev->maximum_num_containers;
1390 ++container) {
1391 /*
1392 * Stomp on all config sequencing for all
1393 * containers?
1394 */
1395 dev->fsa_dev[container].config_waiting_on =
1396 AifEnContainerChange;
1397 dev->fsa_dev[container].config_needed = DELETE;
1398 dev->fsa_dev[container].config_waiting_stamp =
1399 jiffies;
1400 }
1401 }
1402 break;
1403 }
1404
1405 container = 0;
1406 retry_next:
1407 if (device_config_needed == NOTHING)
1408 for (; container < dev->maximum_num_containers; ++container) {
1409 if ((dev->fsa_dev[container].config_waiting_on == 0) &&
1410 (dev->fsa_dev[container].config_needed != NOTHING) &&
1411 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) {
1412 device_config_needed =
1413 dev->fsa_dev[container].config_needed;
1414 dev->fsa_dev[container].config_needed = NOTHING;
1415 channel = CONTAINER_TO_CHANNEL(container);
1416 id = CONTAINER_TO_ID(container);
1417 lun = CONTAINER_TO_LUN(container);
1418 break;
1419 }
1420 }
1421 if (device_config_needed == NOTHING)
1422 return;
1423
1424 /*
1425 * If we decided that a re-configuration needs to be done,
1426 * schedule it here on the way out the door, please close the door
1427 * behind you.
1428 */
1429
1430 /*
1431 * Find the scsi_device associated with the SCSI address,
1432 * and mark it as changed, invalidating the cache. This deals
1433 * with changes to existing device IDs.
1434 */
1435
1436 if (!dev || !dev->scsi_host_ptr)
1437 return;
1438 /*
1439 * force reload of disk info via aac_probe_container
1440 */
1441 if ((channel == CONTAINER_CHANNEL) &&
1442 (device_config_needed != NOTHING)) {
1443 if (dev->fsa_dev[container].valid == 1)
1444 dev->fsa_dev[container].valid = 2;
1445 aac_probe_container(dev, container);
1446 }
1447 device = scsi_device_lookup(dev->scsi_host_ptr, channel, id, lun);
1448 if (device) {
1449 switch (device_config_needed) {
1450 case DELETE:
1451 #if (defined(AAC_DEBUG_INSTRUMENT_AIF_DELETE))
1452 scsi_remove_device(device);
1453 #else
1454 if (scsi_device_online(device)) {
1455 scsi_device_set_state(device, SDEV_OFFLINE);
1456 sdev_printk(KERN_INFO, device,
1457 "Device offlined - %s\n",
1458 (channel == CONTAINER_CHANNEL) ?
1459 "array deleted" :
1460 "enclosure services event");
1461 }
1462 #endif
1463 break;
1464 case ADD:
1465 if (!scsi_device_online(device)) {
1466 sdev_printk(KERN_INFO, device,
1467 "Device online - %s\n",
1468 (channel == CONTAINER_CHANNEL) ?
1469 "array created" :
1470 "enclosure services event");
1471 scsi_device_set_state(device, SDEV_RUNNING);
1472 }
1473 /* FALLTHRU */
1474 case CHANGE:
1475 if ((channel == CONTAINER_CHANNEL)
1476 && (!dev->fsa_dev[container].valid)) {
1477 #if (defined(AAC_DEBUG_INSTRUMENT_AIF_DELETE))
1478 scsi_remove_device(device);
1479 #else
1480 if (!scsi_device_online(device))
1481 break;
1482 scsi_device_set_state(device, SDEV_OFFLINE);
1483 sdev_printk(KERN_INFO, device,
1484 "Device offlined - %s\n",
1485 "array failed");
1486 #endif
1487 break;
1488 }
1489 scsi_rescan_device(&device->sdev_gendev);
1490
1491 default:
1492 break;
1493 }
1494 scsi_device_put(device);
1495 device_config_needed = NOTHING;
1496 }
1497 if (device_config_needed == ADD)
1498 scsi_add_device(dev->scsi_host_ptr, channel, id, lun);
1499 if (channel == CONTAINER_CHANNEL) {
1500 container++;
1501 device_config_needed = NOTHING;
1502 goto retry_next;
1503 }
1504 }
1505
1506 static int _aac_reset_adapter(struct aac_dev *aac, int forced, u8 reset_type)
1507 {
1508 int index, quirks;
1509 int retval;
1510 struct Scsi_Host *host;
1511 struct scsi_device *dev;
1512 struct scsi_cmnd *command;
1513 struct scsi_cmnd *command_list;
1514 int jafo = 0;
1515 int bled;
1516
1517 /*
1518 * Assumptions:
1519 * - host is locked, unless called by the aacraid thread.
1520 * (a matter of convenience, due to legacy issues surrounding
1521 * eh_host_adapter_reset).
1522 * - in_reset is asserted, so no new i/o is getting to the
1523 * card.
1524 * - The card is dead, or will be very shortly ;-/ so no new
1525 * commands are completing in the interrupt service.
1526 */
1527 host = aac->scsi_host_ptr;
1528 scsi_block_requests(host);
1529 aac_adapter_disable_int(aac);
1530 if (aac->thread->pid != current->pid) {
1531 spin_unlock_irq(host->host_lock);
1532 kthread_stop(aac->thread);
1533 jafo = 1;
1534 }
1535
1536 /*
1537 * If a positive health, means in a known DEAD PANIC
1538 * state and the adapter could be reset to `try again'.
1539 */
1540 bled = forced ? 0 : aac_adapter_check_health(aac);
1541 retval = aac_adapter_restart(aac, bled, reset_type);
1542
1543 if (retval)
1544 goto out;
1545
1546 /*
1547 * Loop through the fibs, close the synchronous FIBS
1548 */
1549 for (retval = 1, index = 0; index < (aac->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); index++) {
1550 struct fib *fib = &aac->fibs[index];
1551 if (!(fib->hw_fib_va->header.XferState & cpu_to_le32(NoResponseExpected | Async)) &&
1552 (fib->hw_fib_va->header.XferState & cpu_to_le32(ResponseExpected))) {
1553 unsigned long flagv;
1554 spin_lock_irqsave(&fib->event_lock, flagv);
1555 up(&fib->event_wait);
1556 spin_unlock_irqrestore(&fib->event_lock, flagv);
1557 schedule();
1558 retval = 0;
1559 }
1560 }
1561 /* Give some extra time for ioctls to complete. */
1562 if (retval == 0)
1563 ssleep(2);
1564 index = aac->cardtype;
1565
1566 /*
1567 * Re-initialize the adapter, first free resources, then carefully
1568 * apply the initialization sequence to come back again. Only risk
1569 * is a change in Firmware dropping cache, it is assumed the caller
1570 * will ensure that i/o is queisced and the card is flushed in that
1571 * case.
1572 */
1573 aac_fib_map_free(aac);
1574 pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, aac->comm_phys);
1575 aac->comm_addr = NULL;
1576 aac->comm_phys = 0;
1577 kfree(aac->queues);
1578 aac->queues = NULL;
1579 aac_free_irq(aac);
1580 kfree(aac->fsa_dev);
1581 aac->fsa_dev = NULL;
1582 quirks = aac_get_driver_ident(index)->quirks;
1583 if (quirks & AAC_QUIRK_31BIT) {
1584 if (((retval = pci_set_dma_mask(aac->pdev, DMA_BIT_MASK(31)))) ||
1585 ((retval = pci_set_consistent_dma_mask(aac->pdev, DMA_BIT_MASK(31)))))
1586 goto out;
1587 } else {
1588 if (((retval = pci_set_dma_mask(aac->pdev, DMA_BIT_MASK(32)))) ||
1589 ((retval = pci_set_consistent_dma_mask(aac->pdev, DMA_BIT_MASK(32)))))
1590 goto out;
1591 }
1592 if ((retval = (*(aac_get_driver_ident(index)->init))(aac)))
1593 goto out;
1594 if (quirks & AAC_QUIRK_31BIT)
1595 if ((retval = pci_set_dma_mask(aac->pdev, DMA_BIT_MASK(32))))
1596 goto out;
1597 if (jafo) {
1598 aac->thread = kthread_run(aac_command_thread, aac, "%s",
1599 aac->name);
1600 if (IS_ERR(aac->thread)) {
1601 retval = PTR_ERR(aac->thread);
1602 goto out;
1603 }
1604 }
1605 (void)aac_get_adapter_info(aac);
1606 if ((quirks & AAC_QUIRK_34SG) && (host->sg_tablesize > 34)) {
1607 host->sg_tablesize = 34;
1608 host->max_sectors = (host->sg_tablesize * 8) + 112;
1609 }
1610 if ((quirks & AAC_QUIRK_17SG) && (host->sg_tablesize > 17)) {
1611 host->sg_tablesize = 17;
1612 host->max_sectors = (host->sg_tablesize * 8) + 112;
1613 }
1614 aac_get_config_status(aac, 1);
1615 aac_get_containers(aac);
1616 /*
1617 * This is where the assumption that the Adapter is quiesced
1618 * is important.
1619 */
1620 command_list = NULL;
1621 __shost_for_each_device(dev, host) {
1622 unsigned long flags;
1623 spin_lock_irqsave(&dev->list_lock, flags);
1624 list_for_each_entry(command, &dev->cmd_list, list)
1625 if (command->SCp.phase == AAC_OWNER_FIRMWARE) {
1626 command->SCp.buffer = (struct scatterlist *)command_list;
1627 command_list = command;
1628 }
1629 spin_unlock_irqrestore(&dev->list_lock, flags);
1630 }
1631 while ((command = command_list)) {
1632 command_list = (struct scsi_cmnd *)command->SCp.buffer;
1633 command->SCp.buffer = NULL;
1634 command->result = DID_OK << 16
1635 | COMMAND_COMPLETE << 8
1636 | SAM_STAT_TASK_SET_FULL;
1637 command->SCp.phase = AAC_OWNER_ERROR_HANDLER;
1638 command->scsi_done(command);
1639 }
1640 retval = 0;
1641
1642 out:
1643 aac->in_reset = 0;
1644 scsi_unblock_requests(host);
1645 if (jafo) {
1646 spin_lock_irq(host->host_lock);
1647 }
1648 return retval;
1649 }
1650
1651 int aac_reset_adapter(struct aac_dev *aac, int forced, u8 reset_type)
1652 {
1653 unsigned long flagv = 0;
1654 int retval;
1655 struct Scsi_Host * host;
1656 int bled;
1657
1658 if (spin_trylock_irqsave(&aac->fib_lock, flagv) == 0)
1659 return -EBUSY;
1660
1661 if (aac->in_reset) {
1662 spin_unlock_irqrestore(&aac->fib_lock, flagv);
1663 return -EBUSY;
1664 }
1665 aac->in_reset = 1;
1666 spin_unlock_irqrestore(&aac->fib_lock, flagv);
1667
1668 /*
1669 * Wait for all commands to complete to this specific
1670 * target (block maximum 60 seconds). Although not necessary,
1671 * it does make us a good storage citizen.
1672 */
1673 host = aac->scsi_host_ptr;
1674 scsi_block_requests(host);
1675 if (forced < 2) for (retval = 60; retval; --retval) {
1676 struct scsi_device * dev;
1677 struct scsi_cmnd * command;
1678 int active = 0;
1679
1680 __shost_for_each_device(dev, host) {
1681 spin_lock_irqsave(&dev->list_lock, flagv);
1682 list_for_each_entry(command, &dev->cmd_list, list) {
1683 if (command->SCp.phase == AAC_OWNER_FIRMWARE) {
1684 active++;
1685 break;
1686 }
1687 }
1688 spin_unlock_irqrestore(&dev->list_lock, flagv);
1689 if (active)
1690 break;
1691
1692 }
1693 /*
1694 * We can exit If all the commands are complete
1695 */
1696 if (active == 0)
1697 break;
1698 ssleep(1);
1699 }
1700
1701 /* Quiesce build, flush cache, write through mode */
1702 if (forced < 2)
1703 aac_send_shutdown(aac);
1704 spin_lock_irqsave(host->host_lock, flagv);
1705 bled = forced ? forced :
1706 (aac_check_reset != 0 && aac_check_reset != 1);
1707 retval = _aac_reset_adapter(aac, bled, reset_type);
1708 spin_unlock_irqrestore(host->host_lock, flagv);
1709
1710 if ((forced < 2) && (retval == -ENODEV)) {
1711 /* Unwind aac_send_shutdown() IOP_RESET unsupported/disabled */
1712 struct fib * fibctx = aac_fib_alloc(aac);
1713 if (fibctx) {
1714 struct aac_pause *cmd;
1715 int status;
1716
1717 aac_fib_init(fibctx);
1718
1719 cmd = (struct aac_pause *) fib_data(fibctx);
1720
1721 cmd->command = cpu_to_le32(VM_ContainerConfig);
1722 cmd->type = cpu_to_le32(CT_PAUSE_IO);
1723 cmd->timeout = cpu_to_le32(1);
1724 cmd->min = cpu_to_le32(1);
1725 cmd->noRescan = cpu_to_le32(1);
1726 cmd->count = cpu_to_le32(0);
1727
1728 status = aac_fib_send(ContainerCommand,
1729 fibctx,
1730 sizeof(struct aac_pause),
1731 FsaNormal,
1732 -2 /* Timeout silently */, 1,
1733 NULL, NULL);
1734
1735 if (status >= 0)
1736 aac_fib_complete(fibctx);
1737 /* FIB should be freed only after getting
1738 * the response from the F/W */
1739 if (status != -ERESTARTSYS)
1740 aac_fib_free(fibctx);
1741 }
1742 }
1743
1744 return retval;
1745 }
1746
1747 int aac_check_health(struct aac_dev * aac)
1748 {
1749 int BlinkLED;
1750 unsigned long time_now, flagv = 0;
1751 struct list_head * entry;
1752 struct Scsi_Host * host;
1753 int bled;
1754
1755 /* Extending the scope of fib_lock slightly to protect aac->in_reset */
1756 if (spin_trylock_irqsave(&aac->fib_lock, flagv) == 0)
1757 return 0;
1758
1759 if (aac->in_reset || !(BlinkLED = aac_adapter_check_health(aac))) {
1760 spin_unlock_irqrestore(&aac->fib_lock, flagv);
1761 return 0; /* OK */
1762 }
1763
1764 aac->in_reset = 1;
1765
1766 /* Fake up an AIF:
1767 * aac_aifcmd.command = AifCmdEventNotify = 1
1768 * aac_aifcmd.seqnum = 0xFFFFFFFF
1769 * aac_aifcmd.data[0] = AifEnExpEvent = 23
1770 * aac_aifcmd.data[1] = AifExeFirmwarePanic = 3
1771 * aac.aifcmd.data[2] = AifHighPriority = 3
1772 * aac.aifcmd.data[3] = BlinkLED
1773 */
1774
1775 time_now = jiffies/HZ;
1776 entry = aac->fib_list.next;
1777
1778 /*
1779 * For each Context that is on the
1780 * fibctxList, make a copy of the
1781 * fib, and then set the event to wake up the
1782 * thread that is waiting for it.
1783 */
1784 while (entry != &aac->fib_list) {
1785 /*
1786 * Extract the fibctx
1787 */
1788 struct aac_fib_context *fibctx = list_entry(entry, struct aac_fib_context, next);
1789 struct hw_fib * hw_fib;
1790 struct fib * fib;
1791 /*
1792 * Check if the queue is getting
1793 * backlogged
1794 */
1795 if (fibctx->count > 20) {
1796 /*
1797 * It's *not* jiffies folks,
1798 * but jiffies / HZ, so do not
1799 * panic ...
1800 */
1801 u32 time_last = fibctx->jiffies;
1802 /*
1803 * Has it been > 2 minutes
1804 * since the last read off
1805 * the queue?
1806 */
1807 if ((time_now - time_last) > aif_timeout) {
1808 entry = entry->next;
1809 aac_close_fib_context(aac, fibctx);
1810 continue;
1811 }
1812 }
1813 /*
1814 * Warning: no sleep allowed while
1815 * holding spinlock
1816 */
1817 hw_fib = kzalloc(sizeof(struct hw_fib), GFP_ATOMIC);
1818 fib = kzalloc(sizeof(struct fib), GFP_ATOMIC);
1819 if (fib && hw_fib) {
1820 struct aac_aifcmd * aif;
1821
1822 fib->hw_fib_va = hw_fib;
1823 fib->dev = aac;
1824 aac_fib_init(fib);
1825 fib->type = FSAFS_NTC_FIB_CONTEXT;
1826 fib->size = sizeof (struct fib);
1827 fib->data = hw_fib->data;
1828 aif = (struct aac_aifcmd *)hw_fib->data;
1829 aif->command = cpu_to_le32(AifCmdEventNotify);
1830 aif->seqnum = cpu_to_le32(0xFFFFFFFF);
1831 ((__le32 *)aif->data)[0] = cpu_to_le32(AifEnExpEvent);
1832 ((__le32 *)aif->data)[1] = cpu_to_le32(AifExeFirmwarePanic);
1833 ((__le32 *)aif->data)[2] = cpu_to_le32(AifHighPriority);
1834 ((__le32 *)aif->data)[3] = cpu_to_le32(BlinkLED);
1835
1836 /*
1837 * Put the FIB onto the
1838 * fibctx's fibs
1839 */
1840 list_add_tail(&fib->fiblink, &fibctx->fib_list);
1841 fibctx->count++;
1842 /*
1843 * Set the event to wake up the
1844 * thread that will waiting.
1845 */
1846 up(&fibctx->wait_sem);
1847 } else {
1848 printk(KERN_WARNING "aifd: didn't allocate NewFib.\n");
1849 kfree(fib);
1850 kfree(hw_fib);
1851 }
1852 entry = entry->next;
1853 }
1854
1855 spin_unlock_irqrestore(&aac->fib_lock, flagv);
1856
1857 if (BlinkLED < 0) {
1858 printk(KERN_ERR "%s: Host adapter dead %d\n", aac->name, BlinkLED);
1859 goto out;
1860 }
1861
1862 printk(KERN_ERR "%s: Host adapter BLINK LED 0x%x\n", aac->name, BlinkLED);
1863
1864 if (!aac_check_reset || ((aac_check_reset == 1) &&
1865 (aac->supplement_adapter_info.supported_options2 &
1866 AAC_OPTION_IGNORE_RESET)))
1867 goto out;
1868 host = aac->scsi_host_ptr;
1869 if (aac->thread->pid != current->pid)
1870 spin_lock_irqsave(host->host_lock, flagv);
1871 bled = aac_check_reset != 1 ? 1 : 0;
1872 _aac_reset_adapter(aac, bled, IOP_HWSOFT_RESET);
1873 if (aac->thread->pid != current->pid)
1874 spin_unlock_irqrestore(host->host_lock, flagv);
1875 return BlinkLED;
1876
1877 out:
1878 aac->in_reset = 0;
1879 return BlinkLED;
1880 }
1881
1882
1883 static void aac_resolve_luns(struct aac_dev *dev)
1884 {
1885 int bus, target, channel;
1886 struct scsi_device *sdev;
1887 u8 devtype;
1888 u8 new_devtype;
1889
1890 for (bus = 0; bus < AAC_MAX_BUSES; bus++) {
1891 for (target = 0; target < AAC_MAX_TARGETS; target++) {
1892
1893 if (aac_phys_to_logical(bus) == ENCLOSURE_CHANNEL)
1894 continue;
1895
1896 if (bus == CONTAINER_CHANNEL)
1897 channel = CONTAINER_CHANNEL;
1898 else
1899 channel = aac_phys_to_logical(bus);
1900
1901 devtype = dev->hba_map[bus][target].devtype;
1902 new_devtype = dev->hba_map[bus][target].new_devtype;
1903
1904 sdev = scsi_device_lookup(dev->scsi_host_ptr, channel,
1905 target, 0);
1906
1907 if (!sdev && devtype)
1908 scsi_add_device(dev->scsi_host_ptr, channel,
1909 target, 0);
1910 else if (sdev && new_devtype != devtype)
1911 scsi_remove_device(sdev);
1912 else if (sdev && new_devtype == devtype)
1913 scsi_rescan_device(&sdev->sdev_gendev);
1914
1915 if (sdev)
1916 scsi_device_put(sdev);
1917
1918 dev->hba_map[bus][target].devtype = new_devtype;
1919 }
1920 }
1921 }
1922
1923 /**
1924 * aac_handle_sa_aif Handle a message from the firmware
1925 * @dev: Which adapter this fib is from
1926 * @fibptr: Pointer to fibptr from adapter
1927 *
1928 * This routine handles a driver notify fib from the adapter and
1929 * dispatches it to the appropriate routine for handling.
1930 */
1931 static void aac_handle_sa_aif(struct aac_dev *dev, struct fib *fibptr)
1932 {
1933 int i, bus, target, container, rcode = 0;
1934 u32 events = 0;
1935 struct fib *fib;
1936 struct scsi_device *sdev;
1937
1938 if (fibptr->hbacmd_size & SA_AIF_HOTPLUG)
1939 events = SA_AIF_HOTPLUG;
1940 else if (fibptr->hbacmd_size & SA_AIF_HARDWARE)
1941 events = SA_AIF_HARDWARE;
1942 else if (fibptr->hbacmd_size & SA_AIF_PDEV_CHANGE)
1943 events = SA_AIF_PDEV_CHANGE;
1944 else if (fibptr->hbacmd_size & SA_AIF_LDEV_CHANGE)
1945 events = SA_AIF_LDEV_CHANGE;
1946 else if (fibptr->hbacmd_size & SA_AIF_BPSTAT_CHANGE)
1947 events = SA_AIF_BPSTAT_CHANGE;
1948 else if (fibptr->hbacmd_size & SA_AIF_BPCFG_CHANGE)
1949 events = SA_AIF_BPCFG_CHANGE;
1950
1951 switch (events) {
1952 case SA_AIF_HOTPLUG:
1953 case SA_AIF_HARDWARE:
1954 case SA_AIF_PDEV_CHANGE:
1955 case SA_AIF_LDEV_CHANGE:
1956 case SA_AIF_BPCFG_CHANGE:
1957
1958 fib = aac_fib_alloc(dev);
1959 if (!fib) {
1960 pr_err("aac_handle_sa_aif: out of memory\n");
1961 return;
1962 }
1963 for (bus = 0; bus < AAC_MAX_BUSES; bus++)
1964 for (target = 0; target < AAC_MAX_TARGETS; target++)
1965 dev->hba_map[bus][target].new_devtype = 0;
1966
1967 rcode = aac_report_phys_luns(dev, fib, AAC_RESCAN);
1968
1969 if (rcode != -ERESTARTSYS)
1970 aac_fib_free(fib);
1971
1972 aac_resolve_luns(dev);
1973
1974 if (events == SA_AIF_LDEV_CHANGE ||
1975 events == SA_AIF_BPCFG_CHANGE) {
1976 aac_get_containers(dev);
1977 for (container = 0; container <
1978 dev->maximum_num_containers; ++container) {
1979 sdev = scsi_device_lookup(dev->scsi_host_ptr,
1980 CONTAINER_CHANNEL,
1981 container, 0);
1982 if (dev->fsa_dev[container].valid && !sdev) {
1983 scsi_add_device(dev->scsi_host_ptr,
1984 CONTAINER_CHANNEL,
1985 container, 0);
1986 } else if (!dev->fsa_dev[container].valid &&
1987 sdev) {
1988 scsi_remove_device(sdev);
1989 scsi_device_put(sdev);
1990 } else if (sdev) {
1991 scsi_rescan_device(&sdev->sdev_gendev);
1992 scsi_device_put(sdev);
1993 }
1994 }
1995 }
1996 break;
1997
1998 case SA_AIF_BPSTAT_CHANGE:
1999 /* currently do nothing */
2000 break;
2001 }
2002
2003 for (i = 1; i <= 10; ++i) {
2004 events = src_readl(dev, MUnit.IDR);
2005 if (events & (1<<23)) {
2006 pr_warn(" AIF not cleared by firmware - %d/%d)\n",
2007 i, 10);
2008 ssleep(1);
2009 }
2010 }
2011 }
2012
2013 static int get_fib_count(struct aac_dev *dev)
2014 {
2015 unsigned int num = 0;
2016 struct list_head *entry;
2017 unsigned long flagv;
2018
2019 /*
2020 * Warning: no sleep allowed while
2021 * holding spinlock. We take the estimate
2022 * and pre-allocate a set of fibs outside the
2023 * lock.
2024 */
2025 num = le32_to_cpu(dev->init->r7.adapter_fibs_size)
2026 / sizeof(struct hw_fib); /* some extra */
2027 spin_lock_irqsave(&dev->fib_lock, flagv);
2028 entry = dev->fib_list.next;
2029 while (entry != &dev->fib_list) {
2030 entry = entry->next;
2031 ++num;
2032 }
2033 spin_unlock_irqrestore(&dev->fib_lock, flagv);
2034
2035 return num;
2036 }
2037
2038 static int fillup_pools(struct aac_dev *dev, struct hw_fib **hw_fib_pool,
2039 struct fib **fib_pool,
2040 unsigned int num)
2041 {
2042 struct hw_fib **hw_fib_p;
2043 struct fib **fib_p;
2044 int rcode = 1;
2045
2046 hw_fib_p = hw_fib_pool;
2047 fib_p = fib_pool;
2048 while (hw_fib_p < &hw_fib_pool[num]) {
2049 *(hw_fib_p) = kmalloc(sizeof(struct hw_fib), GFP_KERNEL);
2050 if (!(*(hw_fib_p++))) {
2051 --hw_fib_p;
2052 break;
2053 }
2054
2055 *(fib_p) = kmalloc(sizeof(struct fib), GFP_KERNEL);
2056 if (!(*(fib_p++))) {
2057 kfree(*(--hw_fib_p));
2058 break;
2059 }
2060 }
2061
2062 num = hw_fib_p - hw_fib_pool;
2063 if (!num)
2064 rcode = 0;
2065
2066 return rcode;
2067 }
2068
2069 static void wakeup_fibctx_threads(struct aac_dev *dev,
2070 struct hw_fib **hw_fib_pool,
2071 struct fib **fib_pool,
2072 struct fib *fib,
2073 struct hw_fib *hw_fib,
2074 unsigned int num)
2075 {
2076 unsigned long flagv;
2077 struct list_head *entry;
2078 struct hw_fib **hw_fib_p;
2079 struct fib **fib_p;
2080 u32 time_now, time_last;
2081 struct hw_fib *hw_newfib;
2082 struct fib *newfib;
2083 struct aac_fib_context *fibctx;
2084
2085 time_now = jiffies/HZ;
2086 spin_lock_irqsave(&dev->fib_lock, flagv);
2087 entry = dev->fib_list.next;
2088 /*
2089 * For each Context that is on the
2090 * fibctxList, make a copy of the
2091 * fib, and then set the event to wake up the
2092 * thread that is waiting for it.
2093 */
2094
2095 hw_fib_p = hw_fib_pool;
2096 fib_p = fib_pool;
2097 while (entry != &dev->fib_list) {
2098 /*
2099 * Extract the fibctx
2100 */
2101 fibctx = list_entry(entry, struct aac_fib_context,
2102 next);
2103 /*
2104 * Check if the queue is getting
2105 * backlogged
2106 */
2107 if (fibctx->count > 20) {
2108 /*
2109 * It's *not* jiffies folks,
2110 * but jiffies / HZ so do not
2111 * panic ...
2112 */
2113 time_last = fibctx->jiffies;
2114 /*
2115 * Has it been > 2 minutes
2116 * since the last read off
2117 * the queue?
2118 */
2119 if ((time_now - time_last) > aif_timeout) {
2120 entry = entry->next;
2121 aac_close_fib_context(dev, fibctx);
2122 continue;
2123 }
2124 }
2125 /*
2126 * Warning: no sleep allowed while
2127 * holding spinlock
2128 */
2129 if (hw_fib_p >= &hw_fib_pool[num]) {
2130 pr_warn("aifd: didn't allocate NewFib\n");
2131 entry = entry->next;
2132 continue;
2133 }
2134
2135 hw_newfib = *hw_fib_p;
2136 *(hw_fib_p++) = NULL;
2137 newfib = *fib_p;
2138 *(fib_p++) = NULL;
2139 /*
2140 * Make the copy of the FIB
2141 */
2142 memcpy(hw_newfib, hw_fib, sizeof(struct hw_fib));
2143 memcpy(newfib, fib, sizeof(struct fib));
2144 newfib->hw_fib_va = hw_newfib;
2145 /*
2146 * Put the FIB onto the
2147 * fibctx's fibs
2148 */
2149 list_add_tail(&newfib->fiblink, &fibctx->fib_list);
2150 fibctx->count++;
2151 /*
2152 * Set the event to wake up the
2153 * thread that is waiting.
2154 */
2155 up(&fibctx->wait_sem);
2156
2157 entry = entry->next;
2158 }
2159 /*
2160 * Set the status of this FIB
2161 */
2162 *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK);
2163 aac_fib_adapter_complete(fib, sizeof(u32));
2164 spin_unlock_irqrestore(&dev->fib_lock, flagv);
2165
2166 }
2167
2168 static void aac_process_events(struct aac_dev *dev)
2169 {
2170 struct hw_fib *hw_fib;
2171 struct fib *fib;
2172 unsigned long flags;
2173 spinlock_t *t_lock;
2174 unsigned int rcode;
2175
2176 t_lock = dev->queues->queue[HostNormCmdQueue].lock;
2177 spin_lock_irqsave(t_lock, flags);
2178
2179 while (!list_empty(&(dev->queues->queue[HostNormCmdQueue].cmdq))) {
2180 struct list_head *entry;
2181 struct aac_aifcmd *aifcmd;
2182 unsigned int num;
2183 struct hw_fib **hw_fib_pool, **hw_fib_p;
2184 struct fib **fib_pool, **fib_p;
2185
2186 set_current_state(TASK_RUNNING);
2187
2188 entry = dev->queues->queue[HostNormCmdQueue].cmdq.next;
2189 list_del(entry);
2190
2191 t_lock = dev->queues->queue[HostNormCmdQueue].lock;
2192 spin_unlock_irqrestore(t_lock, flags);
2193
2194 fib = list_entry(entry, struct fib, fiblink);
2195 hw_fib = fib->hw_fib_va;
2196 if (dev->sa_firmware) {
2197 /* Thor AIF */
2198 aac_handle_sa_aif(dev, fib);
2199 aac_fib_adapter_complete(fib, (u16)sizeof(u32));
2200 continue;
2201 }
2202 /*
2203 * We will process the FIB here or pass it to a
2204 * worker thread that is TBD. We Really can't
2205 * do anything at this point since we don't have
2206 * anything defined for this thread to do.
2207 */
2208 memset(fib, 0, sizeof(struct fib));
2209 fib->type = FSAFS_NTC_FIB_CONTEXT;
2210 fib->size = sizeof(struct fib);
2211 fib->hw_fib_va = hw_fib;
2212 fib->data = hw_fib->data;
2213 fib->dev = dev;
2214 /*
2215 * We only handle AifRequest fibs from the adapter.
2216 */
2217
2218 aifcmd = (struct aac_aifcmd *) hw_fib->data;
2219 if (aifcmd->command == cpu_to_le32(AifCmdDriverNotify)) {
2220 /* Handle Driver Notify Events */
2221 aac_handle_aif(dev, fib);
2222 *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK);
2223 aac_fib_adapter_complete(fib, (u16)sizeof(u32));
2224 goto free_fib;
2225 }
2226 /*
2227 * The u32 here is important and intended. We are using
2228 * 32bit wrapping time to fit the adapter field
2229 */
2230
2231 /* Sniff events */
2232 if (aifcmd->command == cpu_to_le32(AifCmdEventNotify)
2233 || aifcmd->command == cpu_to_le32(AifCmdJobProgress)) {
2234 aac_handle_aif(dev, fib);
2235 }
2236
2237 /*
2238 * get number of fibs to process
2239 */
2240 num = get_fib_count(dev);
2241 if (!num)
2242 goto free_fib;
2243
2244 hw_fib_pool = kmalloc_array(num, sizeof(struct hw_fib *),
2245 GFP_KERNEL);
2246 if (!hw_fib_pool)
2247 goto free_fib;
2248
2249 fib_pool = kmalloc_array(num, sizeof(struct fib *), GFP_KERNEL);
2250 if (!fib_pool)
2251 goto free_hw_fib_pool;
2252
2253 /*
2254 * Fill up fib pointer pools with actual fibs
2255 * and hw_fibs
2256 */
2257 rcode = fillup_pools(dev, hw_fib_pool, fib_pool, num);
2258 if (!rcode)
2259 goto free_mem;
2260
2261 /*
2262 * wakeup the thread that is waiting for
2263 * the response from fw (ioctl)
2264 */
2265 wakeup_fibctx_threads(dev, hw_fib_pool, fib_pool,
2266 fib, hw_fib, num);
2267
2268 free_mem:
2269 /* Free up the remaining resources */
2270 hw_fib_p = hw_fib_pool;
2271 fib_p = fib_pool;
2272 while (hw_fib_p < &hw_fib_pool[num]) {
2273 kfree(*hw_fib_p);
2274 kfree(*fib_p);
2275 ++fib_p;
2276 ++hw_fib_p;
2277 }
2278 kfree(fib_pool);
2279 free_hw_fib_pool:
2280 kfree(hw_fib_pool);
2281 free_fib:
2282 kfree(fib);
2283 t_lock = dev->queues->queue[HostNormCmdQueue].lock;
2284 spin_lock_irqsave(t_lock, flags);
2285 }
2286 /*
2287 * There are no more AIF's
2288 */
2289 t_lock = dev->queues->queue[HostNormCmdQueue].lock;
2290 spin_unlock_irqrestore(t_lock, flags);
2291 }
2292
2293 static int aac_send_wellness_command(struct aac_dev *dev, char *wellness_str,
2294 u32 datasize)
2295 {
2296 struct aac_srb *srbcmd;
2297 struct sgmap64 *sg64;
2298 dma_addr_t addr;
2299 char *dma_buf;
2300 struct fib *fibptr;
2301 int ret = -ENOMEM;
2302 u32 vbus, vid;
2303
2304 fibptr = aac_fib_alloc(dev);
2305 if (!fibptr)
2306 goto out;
2307
2308 dma_buf = pci_alloc_consistent(dev->pdev, datasize, &addr);
2309 if (!dma_buf)
2310 goto fib_free_out;
2311
2312 aac_fib_init(fibptr);
2313
2314 vbus = (u32)le16_to_cpu(dev->supplement_adapter_info.virt_device_bus);
2315 vid = (u32)le16_to_cpu(dev->supplement_adapter_info.virt_device_target);
2316
2317 srbcmd = (struct aac_srb *)fib_data(fibptr);
2318
2319 srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi);
2320 srbcmd->channel = cpu_to_le32(vbus);
2321 srbcmd->id = cpu_to_le32(vid);
2322 srbcmd->lun = 0;
2323 srbcmd->flags = cpu_to_le32(SRB_DataOut);
2324 srbcmd->timeout = cpu_to_le32(10);
2325 srbcmd->retry_limit = 0;
2326 srbcmd->cdb_size = cpu_to_le32(12);
2327 srbcmd->count = cpu_to_le32(datasize);
2328
2329 memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb));
2330 srbcmd->cdb[0] = BMIC_OUT;
2331 srbcmd->cdb[6] = WRITE_HOST_WELLNESS;
2332 memcpy(dma_buf, (char *)wellness_str, datasize);
2333
2334 sg64 = (struct sgmap64 *)&srbcmd->sg;
2335 sg64->count = cpu_to_le32(1);
2336 sg64->sg[0].addr[1] = cpu_to_le32((u32)(((addr) >> 16) >> 16));
2337 sg64->sg[0].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff));
2338 sg64->sg[0].count = cpu_to_le32(datasize);
2339
2340 ret = aac_fib_send(ScsiPortCommand64, fibptr, sizeof(struct aac_srb),
2341 FsaNormal, 1, 1, NULL, NULL);
2342
2343 pci_free_consistent(dev->pdev, datasize, (void *)dma_buf, addr);
2344
2345 /*
2346 * Do not set XferState to zero unless
2347 * receives a response from F/W
2348 */
2349 if (ret >= 0)
2350 aac_fib_complete(fibptr);
2351
2352 /*
2353 * FIB should be freed only after
2354 * getting the response from the F/W
2355 */
2356 if (ret != -ERESTARTSYS)
2357 goto fib_free_out;
2358
2359 out:
2360 return ret;
2361 fib_free_out:
2362 aac_fib_free(fibptr);
2363 goto out;
2364 }
2365
2366 int aac_send_safw_hostttime(struct aac_dev *dev, struct timeval *now)
2367 {
2368 struct tm cur_tm;
2369 char wellness_str[] = "<HW>TD\010\0\0\0\0\0\0\0\0\0DW\0\0ZZ";
2370 u32 datasize = sizeof(wellness_str);
2371 unsigned long local_time;
2372 int ret = -ENODEV;
2373
2374 if (!dev->sa_firmware)
2375 goto out;
2376
2377 local_time = (u32)(now->tv_sec - (sys_tz.tz_minuteswest * 60));
2378 time_to_tm(local_time, 0, &cur_tm);
2379 cur_tm.tm_mon += 1;
2380 cur_tm.tm_year += 1900;
2381 wellness_str[8] = bin2bcd(cur_tm.tm_hour);
2382 wellness_str[9] = bin2bcd(cur_tm.tm_min);
2383 wellness_str[10] = bin2bcd(cur_tm.tm_sec);
2384 wellness_str[12] = bin2bcd(cur_tm.tm_mon);
2385 wellness_str[13] = bin2bcd(cur_tm.tm_mday);
2386 wellness_str[14] = bin2bcd(cur_tm.tm_year / 100);
2387 wellness_str[15] = bin2bcd(cur_tm.tm_year % 100);
2388
2389 ret = aac_send_wellness_command(dev, wellness_str, datasize);
2390
2391 out:
2392 return ret;
2393 }
2394
2395 int aac_send_hosttime(struct aac_dev *dev, struct timeval *now)
2396 {
2397 int ret = -ENOMEM;
2398 struct fib *fibptr;
2399 __le32 *info;
2400
2401 fibptr = aac_fib_alloc(dev);
2402 if (!fibptr)
2403 goto out;
2404
2405 aac_fib_init(fibptr);
2406 info = (__le32 *)fib_data(fibptr);
2407 *info = cpu_to_le32(now->tv_sec);
2408 ret = aac_fib_send(SendHostTime, fibptr, sizeof(*info), FsaNormal,
2409 1, 1, NULL, NULL);
2410
2411 /*
2412 * Do not set XferState to zero unless
2413 * receives a response from F/W
2414 */
2415 if (ret >= 0)
2416 aac_fib_complete(fibptr);
2417
2418 /*
2419 * FIB should be freed only after
2420 * getting the response from the F/W
2421 */
2422 if (ret != -ERESTARTSYS)
2423 aac_fib_free(fibptr);
2424
2425 out:
2426 return ret;
2427 }
2428
2429 /**
2430 * aac_command_thread - command processing thread
2431 * @dev: Adapter to monitor
2432 *
2433 * Waits on the commandready event in it's queue. When the event gets set
2434 * it will pull FIBs off it's queue. It will continue to pull FIBs off
2435 * until the queue is empty. When the queue is empty it will wait for
2436 * more FIBs.
2437 */
2438
2439 int aac_command_thread(void *data)
2440 {
2441 struct aac_dev *dev = data;
2442 DECLARE_WAITQUEUE(wait, current);
2443 unsigned long next_jiffies = jiffies + HZ;
2444 unsigned long next_check_jiffies = next_jiffies;
2445 long difference = HZ;
2446
2447 /*
2448 * We can only have one thread per adapter for AIF's.
2449 */
2450 if (dev->aif_thread)
2451 return -EINVAL;
2452
2453 /*
2454 * Let the DPC know it has a place to send the AIF's to.
2455 */
2456 dev->aif_thread = 1;
2457 add_wait_queue(&dev->queues->queue[HostNormCmdQueue].cmdready, &wait);
2458 set_current_state(TASK_INTERRUPTIBLE);
2459 dprintk ((KERN_INFO "aac_command_thread start\n"));
2460 while (1) {
2461
2462 aac_process_events(dev);
2463
2464 /*
2465 * Background activity
2466 */
2467 if ((time_before(next_check_jiffies,next_jiffies))
2468 && ((difference = next_check_jiffies - jiffies) <= 0)) {
2469 next_check_jiffies = next_jiffies;
2470 if (aac_check_health(dev) == 0) {
2471 difference = ((long)(unsigned)check_interval)
2472 * HZ;
2473 next_check_jiffies = jiffies + difference;
2474 } else if (!dev->queues)
2475 break;
2476 }
2477 if (!time_before(next_check_jiffies,next_jiffies)
2478 && ((difference = next_jiffies - jiffies) <= 0)) {
2479 struct timeval now;
2480 int ret;
2481
2482 /* Don't even try to talk to adapter if its sick */
2483 ret = aac_check_health(dev);
2484 if (!dev->queues)
2485 break;
2486 next_check_jiffies = jiffies
2487 + ((long)(unsigned)check_interval)
2488 * HZ;
2489 do_gettimeofday(&now);
2490
2491 /* Synchronize our watches */
2492 if (((1000000 - (1000000 / HZ)) > now.tv_usec)
2493 && (now.tv_usec > (1000000 / HZ)))
2494 difference = (((1000000 - now.tv_usec) * HZ)
2495 + 500000) / 1000000;
2496 else if (ret == 0) {
2497
2498 if (now.tv_usec > 500000)
2499 ++now.tv_sec;
2500
2501 if (dev->sa_firmware)
2502 ret =
2503 aac_send_safw_hostttime(dev, &now);
2504 else
2505 ret = aac_send_hosttime(dev, &now);
2506
2507 difference = (long)(unsigned)update_interval*HZ;
2508 } else {
2509 /* retry shortly */
2510 difference = 10 * HZ;
2511 }
2512 next_jiffies = jiffies + difference;
2513 if (time_before(next_check_jiffies,next_jiffies))
2514 difference = next_check_jiffies - jiffies;
2515 }
2516 if (difference <= 0)
2517 difference = 1;
2518 set_current_state(TASK_INTERRUPTIBLE);
2519
2520 if (kthread_should_stop())
2521 break;
2522
2523 schedule_timeout(difference);
2524
2525 if (kthread_should_stop())
2526 break;
2527 }
2528 if (dev->queues)
2529 remove_wait_queue(&dev->queues->queue[HostNormCmdQueue].cmdready, &wait);
2530 dev->aif_thread = 0;
2531 return 0;
2532 }
2533
2534 int aac_acquire_irq(struct aac_dev *dev)
2535 {
2536 int i;
2537 int j;
2538 int ret = 0;
2539
2540 if (!dev->sync_mode && dev->msi_enabled && dev->max_msix > 1) {
2541 for (i = 0; i < dev->max_msix; i++) {
2542 dev->aac_msix[i].vector_no = i;
2543 dev->aac_msix[i].dev = dev;
2544 if (request_irq(pci_irq_vector(dev->pdev, i),
2545 dev->a_ops.adapter_intr,
2546 0, "aacraid", &(dev->aac_msix[i]))) {
2547 printk(KERN_ERR "%s%d: Failed to register IRQ for vector %d.\n",
2548 dev->name, dev->id, i);
2549 for (j = 0 ; j < i ; j++)
2550 free_irq(pci_irq_vector(dev->pdev, j),
2551 &(dev->aac_msix[j]));
2552 pci_disable_msix(dev->pdev);
2553 ret = -1;
2554 }
2555 }
2556 } else {
2557 dev->aac_msix[0].vector_no = 0;
2558 dev->aac_msix[0].dev = dev;
2559
2560 if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr,
2561 IRQF_SHARED, "aacraid",
2562 &(dev->aac_msix[0])) < 0) {
2563 if (dev->msi)
2564 pci_disable_msi(dev->pdev);
2565 printk(KERN_ERR "%s%d: Interrupt unavailable.\n",
2566 dev->name, dev->id);
2567 ret = -1;
2568 }
2569 }
2570 return ret;
2571 }
2572
2573 void aac_free_irq(struct aac_dev *dev)
2574 {
2575 int i;
2576 int cpu;
2577
2578 cpu = cpumask_first(cpu_online_mask);
2579 if (dev->pdev->device == PMC_DEVICE_S6 ||
2580 dev->pdev->device == PMC_DEVICE_S7 ||
2581 dev->pdev->device == PMC_DEVICE_S8 ||
2582 dev->pdev->device == PMC_DEVICE_S9) {
2583 if (dev->max_msix > 1) {
2584 for (i = 0; i < dev->max_msix; i++)
2585 free_irq(pci_irq_vector(dev->pdev, i),
2586 &(dev->aac_msix[i]));
2587 } else {
2588 free_irq(dev->pdev->irq, &(dev->aac_msix[0]));
2589 }
2590 } else {
2591 free_irq(dev->pdev->irq, dev);
2592 }
2593 if (dev->msi)
2594 pci_disable_msi(dev->pdev);
2595 else if (dev->max_msix > 1)
2596 pci_disable_msix(dev->pdev);
2597 }
(deprecated) Btrfs devel tree