ia64/linux-2.6.18-xen.hg

view drivers/block/DAC960.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 3e8752eb6d9c
children
line source
1 /*
3 Linux Driver for Mylex DAC960/AcceleRAID/eXtremeRAID PCI RAID Controllers
5 Copyright 1998-2001 by Leonard N. Zubkoff <lnz@dandelion.com>
6 Portions Copyright 2002 by Mylex (An IBM Business Unit)
8 This program is free software; you may redistribute and/or modify it under
9 the terms of the GNU General Public License Version 2 as published by the
10 Free Software Foundation.
12 This program is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY, without even the implied warranty of MERCHANTABILITY
14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for complete details.
17 */
20 #define DAC960_DriverVersion "2.5.48"
21 #define DAC960_DriverDate "14 May 2006"
24 #include <linux/module.h>
25 #include <linux/types.h>
26 #include <linux/miscdevice.h>
27 #include <linux/blkdev.h>
28 #include <linux/bio.h>
29 #include <linux/completion.h>
30 #include <linux/delay.h>
31 #include <linux/genhd.h>
32 #include <linux/hdreg.h>
33 #include <linux/blkpg.h>
34 #include <linux/interrupt.h>
35 #include <linux/ioport.h>
36 #include <linux/mm.h>
37 #include <linux/slab.h>
38 #include <linux/proc_fs.h>
39 #include <linux/reboot.h>
40 #include <linux/spinlock.h>
41 #include <linux/timer.h>
42 #include <linux/pci.h>
43 #include <linux/init.h>
44 #include <linux/jiffies.h>
45 #include <linux/random.h>
46 #include <asm/io.h>
47 #include <asm/uaccess.h>
48 #include "DAC960.h"
50 #define DAC960_GAM_MINOR 252
53 static DAC960_Controller_T *DAC960_Controllers[DAC960_MaxControllers];
54 static int DAC960_ControllerCount;
55 static struct proc_dir_entry *DAC960_ProcDirectoryEntry;
57 static long disk_size(DAC960_Controller_T *p, int drive_nr)
58 {
59 if (p->FirmwareType == DAC960_V1_Controller) {
60 if (drive_nr >= p->LogicalDriveCount)
61 return 0;
62 return p->V1.LogicalDriveInformation[drive_nr].
63 LogicalDriveSize;
64 } else {
65 DAC960_V2_LogicalDeviceInfo_T *i =
66 p->V2.LogicalDeviceInformation[drive_nr];
67 if (i == NULL)
68 return 0;
69 return i->ConfigurableDeviceSize;
70 }
71 }
73 static int DAC960_open(struct inode *inode, struct file *file)
74 {
75 struct gendisk *disk = inode->i_bdev->bd_disk;
76 DAC960_Controller_T *p = disk->queue->queuedata;
77 int drive_nr = (long)disk->private_data;
79 if (p->FirmwareType == DAC960_V1_Controller) {
80 if (p->V1.LogicalDriveInformation[drive_nr].
81 LogicalDriveState == DAC960_V1_LogicalDrive_Offline)
82 return -ENXIO;
83 } else {
84 DAC960_V2_LogicalDeviceInfo_T *i =
85 p->V2.LogicalDeviceInformation[drive_nr];
86 if (!i || i->LogicalDeviceState == DAC960_V2_LogicalDevice_Offline)
87 return -ENXIO;
88 }
90 check_disk_change(inode->i_bdev);
92 if (!get_capacity(p->disks[drive_nr]))
93 return -ENXIO;
94 return 0;
95 }
97 static int DAC960_getgeo(struct block_device *bdev, struct hd_geometry *geo)
98 {
99 struct gendisk *disk = bdev->bd_disk;
100 DAC960_Controller_T *p = disk->queue->queuedata;
101 int drive_nr = (long)disk->private_data;
103 if (p->FirmwareType == DAC960_V1_Controller) {
104 geo->heads = p->V1.GeometryTranslationHeads;
105 geo->sectors = p->V1.GeometryTranslationSectors;
106 geo->cylinders = p->V1.LogicalDriveInformation[drive_nr].
107 LogicalDriveSize / (geo->heads * geo->sectors);
108 } else {
109 DAC960_V2_LogicalDeviceInfo_T *i =
110 p->V2.LogicalDeviceInformation[drive_nr];
111 switch (i->DriveGeometry) {
112 case DAC960_V2_Geometry_128_32:
113 geo->heads = 128;
114 geo->sectors = 32;
115 break;
116 case DAC960_V2_Geometry_255_63:
117 geo->heads = 255;
118 geo->sectors = 63;
119 break;
120 default:
121 DAC960_Error("Illegal Logical Device Geometry %d\n",
122 p, i->DriveGeometry);
123 return -EINVAL;
124 }
126 geo->cylinders = i->ConfigurableDeviceSize /
127 (geo->heads * geo->sectors);
128 }
130 return 0;
131 }
133 static int DAC960_media_changed(struct gendisk *disk)
134 {
135 DAC960_Controller_T *p = disk->queue->queuedata;
136 int drive_nr = (long)disk->private_data;
138 if (!p->LogicalDriveInitiallyAccessible[drive_nr])
139 return 1;
140 return 0;
141 }
143 static int DAC960_revalidate_disk(struct gendisk *disk)
144 {
145 DAC960_Controller_T *p = disk->queue->queuedata;
146 int unit = (long)disk->private_data;
148 set_capacity(disk, disk_size(p, unit));
149 return 0;
150 }
152 static struct block_device_operations DAC960_BlockDeviceOperations = {
153 .owner = THIS_MODULE,
154 .open = DAC960_open,
155 .getgeo = DAC960_getgeo,
156 .media_changed = DAC960_media_changed,
157 .revalidate_disk = DAC960_revalidate_disk,
158 };
161 /*
162 DAC960_AnnounceDriver announces the Driver Version and Date, Author's Name,
163 Copyright Notice, and Electronic Mail Address.
164 */
166 static void DAC960_AnnounceDriver(DAC960_Controller_T *Controller)
167 {
168 DAC960_Announce("***** DAC960 RAID Driver Version "
169 DAC960_DriverVersion " of "
170 DAC960_DriverDate " *****\n", Controller);
171 DAC960_Announce("Copyright 1998-2001 by Leonard N. Zubkoff "
172 "<lnz@dandelion.com>\n", Controller);
173 }
176 /*
177 DAC960_Failure prints a standardized error message, and then returns false.
178 */
180 static boolean DAC960_Failure(DAC960_Controller_T *Controller,
181 unsigned char *ErrorMessage)
182 {
183 DAC960_Error("While configuring DAC960 PCI RAID Controller at\n",
184 Controller);
185 if (Controller->IO_Address == 0)
186 DAC960_Error("PCI Bus %d Device %d Function %d I/O Address N/A "
187 "PCI Address 0x%X\n", Controller,
188 Controller->Bus, Controller->Device,
189 Controller->Function, Controller->PCI_Address);
190 else DAC960_Error("PCI Bus %d Device %d Function %d I/O Address "
191 "0x%X PCI Address 0x%X\n", Controller,
192 Controller->Bus, Controller->Device,
193 Controller->Function, Controller->IO_Address,
194 Controller->PCI_Address);
195 DAC960_Error("%s FAILED - DETACHING\n", Controller, ErrorMessage);
196 return false;
197 }
199 /*
200 init_dma_loaf() and slice_dma_loaf() are helper functions for
201 aggregating the dma-mapped memory for a well-known collection of
202 data structures that are of different lengths.
204 These routines don't guarantee any alignment. The caller must
205 include any space needed for alignment in the sizes of the structures
206 that are passed in.
207 */
209 static boolean init_dma_loaf(struct pci_dev *dev, struct dma_loaf *loaf,
210 size_t len)
211 {
212 void *cpu_addr;
213 dma_addr_t dma_handle;
215 cpu_addr = pci_alloc_consistent(dev, len, &dma_handle);
216 if (cpu_addr == NULL)
217 return false;
219 loaf->cpu_free = loaf->cpu_base = cpu_addr;
220 loaf->dma_free =loaf->dma_base = dma_handle;
221 loaf->length = len;
222 memset(cpu_addr, 0, len);
223 return true;
224 }
226 static void *slice_dma_loaf(struct dma_loaf *loaf, size_t len,
227 dma_addr_t *dma_handle)
228 {
229 void *cpu_end = loaf->cpu_free + len;
230 void *cpu_addr = loaf->cpu_free;
232 BUG_ON(cpu_end > loaf->cpu_base + loaf->length);
233 *dma_handle = loaf->dma_free;
234 loaf->cpu_free = cpu_end;
235 loaf->dma_free += len;
236 return cpu_addr;
237 }
239 static void free_dma_loaf(struct pci_dev *dev, struct dma_loaf *loaf_handle)
240 {
241 if (loaf_handle->cpu_base != NULL)
242 pci_free_consistent(dev, loaf_handle->length,
243 loaf_handle->cpu_base, loaf_handle->dma_base);
244 }
247 /*
248 DAC960_CreateAuxiliaryStructures allocates and initializes the auxiliary
249 data structures for Controller. It returns true on success and false on
250 failure.
251 */
253 static boolean DAC960_CreateAuxiliaryStructures(DAC960_Controller_T *Controller)
254 {
255 int CommandAllocationLength, CommandAllocationGroupSize;
256 int CommandsRemaining = 0, CommandIdentifier, CommandGroupByteCount;
257 void *AllocationPointer = NULL;
258 void *ScatterGatherCPU = NULL;
259 dma_addr_t ScatterGatherDMA;
260 struct pci_pool *ScatterGatherPool;
261 void *RequestSenseCPU = NULL;
262 dma_addr_t RequestSenseDMA;
263 struct pci_pool *RequestSensePool = NULL;
265 if (Controller->FirmwareType == DAC960_V1_Controller)
266 {
267 CommandAllocationLength = offsetof(DAC960_Command_T, V1.EndMarker);
268 CommandAllocationGroupSize = DAC960_V1_CommandAllocationGroupSize;
269 ScatterGatherPool = pci_pool_create("DAC960_V1_ScatterGather",
270 Controller->PCIDevice,
271 DAC960_V1_ScatterGatherLimit * sizeof(DAC960_V1_ScatterGatherSegment_T),
272 sizeof(DAC960_V1_ScatterGatherSegment_T), 0);
273 if (ScatterGatherPool == NULL)
274 return DAC960_Failure(Controller,
275 "AUXILIARY STRUCTURE CREATION (SG)");
276 Controller->ScatterGatherPool = ScatterGatherPool;
277 }
278 else
279 {
280 CommandAllocationLength = offsetof(DAC960_Command_T, V2.EndMarker);
281 CommandAllocationGroupSize = DAC960_V2_CommandAllocationGroupSize;
282 ScatterGatherPool = pci_pool_create("DAC960_V2_ScatterGather",
283 Controller->PCIDevice,
284 DAC960_V2_ScatterGatherLimit * sizeof(DAC960_V2_ScatterGatherSegment_T),
285 sizeof(DAC960_V2_ScatterGatherSegment_T), 0);
286 if (ScatterGatherPool == NULL)
287 return DAC960_Failure(Controller,
288 "AUXILIARY STRUCTURE CREATION (SG)");
289 RequestSensePool = pci_pool_create("DAC960_V2_RequestSense",
290 Controller->PCIDevice, sizeof(DAC960_SCSI_RequestSense_T),
291 sizeof(int), 0);
292 if (RequestSensePool == NULL) {
293 pci_pool_destroy(ScatterGatherPool);
294 return DAC960_Failure(Controller,
295 "AUXILIARY STRUCTURE CREATION (SG)");
296 }
297 Controller->ScatterGatherPool = ScatterGatherPool;
298 Controller->V2.RequestSensePool = RequestSensePool;
299 }
300 Controller->CommandAllocationGroupSize = CommandAllocationGroupSize;
301 Controller->FreeCommands = NULL;
302 for (CommandIdentifier = 1;
303 CommandIdentifier <= Controller->DriverQueueDepth;
304 CommandIdentifier++)
305 {
306 DAC960_Command_T *Command;
307 if (--CommandsRemaining <= 0)
308 {
309 CommandsRemaining =
310 Controller->DriverQueueDepth - CommandIdentifier + 1;
311 if (CommandsRemaining > CommandAllocationGroupSize)
312 CommandsRemaining = CommandAllocationGroupSize;
313 CommandGroupByteCount =
314 CommandsRemaining * CommandAllocationLength;
315 AllocationPointer = kzalloc(CommandGroupByteCount, GFP_ATOMIC);
316 if (AllocationPointer == NULL)
317 return DAC960_Failure(Controller,
318 "AUXILIARY STRUCTURE CREATION");
319 }
320 Command = (DAC960_Command_T *) AllocationPointer;
321 AllocationPointer += CommandAllocationLength;
322 Command->CommandIdentifier = CommandIdentifier;
323 Command->Controller = Controller;
324 Command->Next = Controller->FreeCommands;
325 Controller->FreeCommands = Command;
326 Controller->Commands[CommandIdentifier-1] = Command;
327 ScatterGatherCPU = pci_pool_alloc(ScatterGatherPool, SLAB_ATOMIC,
328 &ScatterGatherDMA);
329 if (ScatterGatherCPU == NULL)
330 return DAC960_Failure(Controller, "AUXILIARY STRUCTURE CREATION");
332 if (RequestSensePool != NULL) {
333 RequestSenseCPU = pci_pool_alloc(RequestSensePool, SLAB_ATOMIC,
334 &RequestSenseDMA);
335 if (RequestSenseCPU == NULL) {
336 pci_pool_free(ScatterGatherPool, ScatterGatherCPU,
337 ScatterGatherDMA);
338 return DAC960_Failure(Controller,
339 "AUXILIARY STRUCTURE CREATION");
340 }
341 }
342 if (Controller->FirmwareType == DAC960_V1_Controller) {
343 Command->cmd_sglist = Command->V1.ScatterList;
344 Command->V1.ScatterGatherList =
345 (DAC960_V1_ScatterGatherSegment_T *)ScatterGatherCPU;
346 Command->V1.ScatterGatherListDMA = ScatterGatherDMA;
347 } else {
348 Command->cmd_sglist = Command->V2.ScatterList;
349 Command->V2.ScatterGatherList =
350 (DAC960_V2_ScatterGatherSegment_T *)ScatterGatherCPU;
351 Command->V2.ScatterGatherListDMA = ScatterGatherDMA;
352 Command->V2.RequestSense =
353 (DAC960_SCSI_RequestSense_T *)RequestSenseCPU;
354 Command->V2.RequestSenseDMA = RequestSenseDMA;
355 }
356 }
357 return true;
358 }
361 /*
362 DAC960_DestroyAuxiliaryStructures deallocates the auxiliary data
363 structures for Controller.
364 */
366 static void DAC960_DestroyAuxiliaryStructures(DAC960_Controller_T *Controller)
367 {
368 int i;
369 struct pci_pool *ScatterGatherPool = Controller->ScatterGatherPool;
370 struct pci_pool *RequestSensePool = NULL;
371 void *ScatterGatherCPU;
372 dma_addr_t ScatterGatherDMA;
373 void *RequestSenseCPU;
374 dma_addr_t RequestSenseDMA;
375 DAC960_Command_T *CommandGroup = NULL;
378 if (Controller->FirmwareType == DAC960_V2_Controller)
379 RequestSensePool = Controller->V2.RequestSensePool;
381 Controller->FreeCommands = NULL;
382 for (i = 0; i < Controller->DriverQueueDepth; i++)
383 {
384 DAC960_Command_T *Command = Controller->Commands[i];
386 if (Command == NULL)
387 continue;
389 if (Controller->FirmwareType == DAC960_V1_Controller) {
390 ScatterGatherCPU = (void *)Command->V1.ScatterGatherList;
391 ScatterGatherDMA = Command->V1.ScatterGatherListDMA;
392 RequestSenseCPU = NULL;
393 RequestSenseDMA = (dma_addr_t)0;
394 } else {
395 ScatterGatherCPU = (void *)Command->V2.ScatterGatherList;
396 ScatterGatherDMA = Command->V2.ScatterGatherListDMA;
397 RequestSenseCPU = (void *)Command->V2.RequestSense;
398 RequestSenseDMA = Command->V2.RequestSenseDMA;
399 }
400 if (ScatterGatherCPU != NULL)
401 pci_pool_free(ScatterGatherPool, ScatterGatherCPU, ScatterGatherDMA);
402 if (RequestSenseCPU != NULL)
403 pci_pool_free(RequestSensePool, RequestSenseCPU, RequestSenseDMA);
405 if ((Command->CommandIdentifier
406 % Controller->CommandAllocationGroupSize) == 1) {
407 /*
408 * We can't free the group of commands until all of the
409 * request sense and scatter gather dma structures are free.
410 * Remember the beginning of the group, but don't free it
411 * until we've reached the beginning of the next group.
412 */
413 kfree(CommandGroup);
414 CommandGroup = Command;
415 }
416 Controller->Commands[i] = NULL;
417 }
418 kfree(CommandGroup);
420 if (Controller->CombinedStatusBuffer != NULL)
421 {
422 kfree(Controller->CombinedStatusBuffer);
423 Controller->CombinedStatusBuffer = NULL;
424 Controller->CurrentStatusBuffer = NULL;
425 }
427 if (ScatterGatherPool != NULL)
428 pci_pool_destroy(ScatterGatherPool);
429 if (Controller->FirmwareType == DAC960_V1_Controller)
430 return;
432 if (RequestSensePool != NULL)
433 pci_pool_destroy(RequestSensePool);
435 for (i = 0; i < DAC960_MaxLogicalDrives; i++) {
436 kfree(Controller->V2.LogicalDeviceInformation[i]);
437 Controller->V2.LogicalDeviceInformation[i] = NULL;
438 }
440 for (i = 0; i < DAC960_V2_MaxPhysicalDevices; i++)
441 {
442 kfree(Controller->V2.PhysicalDeviceInformation[i]);
443 Controller->V2.PhysicalDeviceInformation[i] = NULL;
444 kfree(Controller->V2.InquiryUnitSerialNumber[i]);
445 Controller->V2.InquiryUnitSerialNumber[i] = NULL;
446 }
447 }
450 /*
451 DAC960_V1_ClearCommand clears critical fields of Command for DAC960 V1
452 Firmware Controllers.
453 */
455 static inline void DAC960_V1_ClearCommand(DAC960_Command_T *Command)
456 {
457 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
458 memset(CommandMailbox, 0, sizeof(DAC960_V1_CommandMailbox_T));
459 Command->V1.CommandStatus = 0;
460 }
463 /*
464 DAC960_V2_ClearCommand clears critical fields of Command for DAC960 V2
465 Firmware Controllers.
466 */
468 static inline void DAC960_V2_ClearCommand(DAC960_Command_T *Command)
469 {
470 DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
471 memset(CommandMailbox, 0, sizeof(DAC960_V2_CommandMailbox_T));
472 Command->V2.CommandStatus = 0;
473 }
476 /*
477 DAC960_AllocateCommand allocates a Command structure from Controller's
478 free list. During driver initialization, a special initialization command
479 has been placed on the free list to guarantee that command allocation can
480 never fail.
481 */
483 static inline DAC960_Command_T *DAC960_AllocateCommand(DAC960_Controller_T
484 *Controller)
485 {
486 DAC960_Command_T *Command = Controller->FreeCommands;
487 if (Command == NULL) return NULL;
488 Controller->FreeCommands = Command->Next;
489 Command->Next = NULL;
490 return Command;
491 }
494 /*
495 DAC960_DeallocateCommand deallocates Command, returning it to Controller's
496 free list.
497 */
499 static inline void DAC960_DeallocateCommand(DAC960_Command_T *Command)
500 {
501 DAC960_Controller_T *Controller = Command->Controller;
503 Command->Request = NULL;
504 Command->Next = Controller->FreeCommands;
505 Controller->FreeCommands = Command;
506 }
509 /*
510 DAC960_WaitForCommand waits for a wake_up on Controller's Command Wait Queue.
511 */
513 static void DAC960_WaitForCommand(DAC960_Controller_T *Controller)
514 {
515 spin_unlock_irq(&Controller->queue_lock);
516 __wait_event(Controller->CommandWaitQueue, Controller->FreeCommands);
517 spin_lock_irq(&Controller->queue_lock);
518 }
520 /*
521 DAC960_GEM_QueueCommand queues Command for DAC960 GEM Series Controllers.
522 */
524 static void DAC960_GEM_QueueCommand(DAC960_Command_T *Command)
525 {
526 DAC960_Controller_T *Controller = Command->Controller;
527 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
528 DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
529 DAC960_V2_CommandMailbox_T *NextCommandMailbox =
530 Controller->V2.NextCommandMailbox;
532 CommandMailbox->Common.CommandIdentifier = Command->CommandIdentifier;
533 DAC960_GEM_WriteCommandMailbox(NextCommandMailbox, CommandMailbox);
535 if (Controller->V2.PreviousCommandMailbox1->Words[0] == 0 ||
536 Controller->V2.PreviousCommandMailbox2->Words[0] == 0)
537 DAC960_GEM_MemoryMailboxNewCommand(ControllerBaseAddress);
539 Controller->V2.PreviousCommandMailbox2 =
540 Controller->V2.PreviousCommandMailbox1;
541 Controller->V2.PreviousCommandMailbox1 = NextCommandMailbox;
543 if (++NextCommandMailbox > Controller->V2.LastCommandMailbox)
544 NextCommandMailbox = Controller->V2.FirstCommandMailbox;
546 Controller->V2.NextCommandMailbox = NextCommandMailbox;
547 }
549 /*
550 DAC960_BA_QueueCommand queues Command for DAC960 BA Series Controllers.
551 */
553 static void DAC960_BA_QueueCommand(DAC960_Command_T *Command)
554 {
555 DAC960_Controller_T *Controller = Command->Controller;
556 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
557 DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
558 DAC960_V2_CommandMailbox_T *NextCommandMailbox =
559 Controller->V2.NextCommandMailbox;
560 CommandMailbox->Common.CommandIdentifier = Command->CommandIdentifier;
561 DAC960_BA_WriteCommandMailbox(NextCommandMailbox, CommandMailbox);
562 if (Controller->V2.PreviousCommandMailbox1->Words[0] == 0 ||
563 Controller->V2.PreviousCommandMailbox2->Words[0] == 0)
564 DAC960_BA_MemoryMailboxNewCommand(ControllerBaseAddress);
565 Controller->V2.PreviousCommandMailbox2 =
566 Controller->V2.PreviousCommandMailbox1;
567 Controller->V2.PreviousCommandMailbox1 = NextCommandMailbox;
568 if (++NextCommandMailbox > Controller->V2.LastCommandMailbox)
569 NextCommandMailbox = Controller->V2.FirstCommandMailbox;
570 Controller->V2.NextCommandMailbox = NextCommandMailbox;
571 }
574 /*
575 DAC960_LP_QueueCommand queues Command for DAC960 LP Series Controllers.
576 */
578 static void DAC960_LP_QueueCommand(DAC960_Command_T *Command)
579 {
580 DAC960_Controller_T *Controller = Command->Controller;
581 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
582 DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
583 DAC960_V2_CommandMailbox_T *NextCommandMailbox =
584 Controller->V2.NextCommandMailbox;
585 CommandMailbox->Common.CommandIdentifier = Command->CommandIdentifier;
586 DAC960_LP_WriteCommandMailbox(NextCommandMailbox, CommandMailbox);
587 if (Controller->V2.PreviousCommandMailbox1->Words[0] == 0 ||
588 Controller->V2.PreviousCommandMailbox2->Words[0] == 0)
589 DAC960_LP_MemoryMailboxNewCommand(ControllerBaseAddress);
590 Controller->V2.PreviousCommandMailbox2 =
591 Controller->V2.PreviousCommandMailbox1;
592 Controller->V2.PreviousCommandMailbox1 = NextCommandMailbox;
593 if (++NextCommandMailbox > Controller->V2.LastCommandMailbox)
594 NextCommandMailbox = Controller->V2.FirstCommandMailbox;
595 Controller->V2.NextCommandMailbox = NextCommandMailbox;
596 }
599 /*
600 DAC960_LA_QueueCommandDualMode queues Command for DAC960 LA Series
601 Controllers with Dual Mode Firmware.
602 */
604 static void DAC960_LA_QueueCommandDualMode(DAC960_Command_T *Command)
605 {
606 DAC960_Controller_T *Controller = Command->Controller;
607 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
608 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
609 DAC960_V1_CommandMailbox_T *NextCommandMailbox =
610 Controller->V1.NextCommandMailbox;
611 CommandMailbox->Common.CommandIdentifier = Command->CommandIdentifier;
612 DAC960_LA_WriteCommandMailbox(NextCommandMailbox, CommandMailbox);
613 if (Controller->V1.PreviousCommandMailbox1->Words[0] == 0 ||
614 Controller->V1.PreviousCommandMailbox2->Words[0] == 0)
615 DAC960_LA_MemoryMailboxNewCommand(ControllerBaseAddress);
616 Controller->V1.PreviousCommandMailbox2 =
617 Controller->V1.PreviousCommandMailbox1;
618 Controller->V1.PreviousCommandMailbox1 = NextCommandMailbox;
619 if (++NextCommandMailbox > Controller->V1.LastCommandMailbox)
620 NextCommandMailbox = Controller->V1.FirstCommandMailbox;
621 Controller->V1.NextCommandMailbox = NextCommandMailbox;
622 }
625 /*
626 DAC960_LA_QueueCommandSingleMode queues Command for DAC960 LA Series
627 Controllers with Single Mode Firmware.
628 */
630 static void DAC960_LA_QueueCommandSingleMode(DAC960_Command_T *Command)
631 {
632 DAC960_Controller_T *Controller = Command->Controller;
633 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
634 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
635 DAC960_V1_CommandMailbox_T *NextCommandMailbox =
636 Controller->V1.NextCommandMailbox;
637 CommandMailbox->Common.CommandIdentifier = Command->CommandIdentifier;
638 DAC960_LA_WriteCommandMailbox(NextCommandMailbox, CommandMailbox);
639 if (Controller->V1.PreviousCommandMailbox1->Words[0] == 0 ||
640 Controller->V1.PreviousCommandMailbox2->Words[0] == 0)
641 DAC960_LA_HardwareMailboxNewCommand(ControllerBaseAddress);
642 Controller->V1.PreviousCommandMailbox2 =
643 Controller->V1.PreviousCommandMailbox1;
644 Controller->V1.PreviousCommandMailbox1 = NextCommandMailbox;
645 if (++NextCommandMailbox > Controller->V1.LastCommandMailbox)
646 NextCommandMailbox = Controller->V1.FirstCommandMailbox;
647 Controller->V1.NextCommandMailbox = NextCommandMailbox;
648 }
651 /*
652 DAC960_PG_QueueCommandDualMode queues Command for DAC960 PG Series
653 Controllers with Dual Mode Firmware.
654 */
656 static void DAC960_PG_QueueCommandDualMode(DAC960_Command_T *Command)
657 {
658 DAC960_Controller_T *Controller = Command->Controller;
659 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
660 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
661 DAC960_V1_CommandMailbox_T *NextCommandMailbox =
662 Controller->V1.NextCommandMailbox;
663 CommandMailbox->Common.CommandIdentifier = Command->CommandIdentifier;
664 DAC960_PG_WriteCommandMailbox(NextCommandMailbox, CommandMailbox);
665 if (Controller->V1.PreviousCommandMailbox1->Words[0] == 0 ||
666 Controller->V1.PreviousCommandMailbox2->Words[0] == 0)
667 DAC960_PG_MemoryMailboxNewCommand(ControllerBaseAddress);
668 Controller->V1.PreviousCommandMailbox2 =
669 Controller->V1.PreviousCommandMailbox1;
670 Controller->V1.PreviousCommandMailbox1 = NextCommandMailbox;
671 if (++NextCommandMailbox > Controller->V1.LastCommandMailbox)
672 NextCommandMailbox = Controller->V1.FirstCommandMailbox;
673 Controller->V1.NextCommandMailbox = NextCommandMailbox;
674 }
677 /*
678 DAC960_PG_QueueCommandSingleMode queues Command for DAC960 PG Series
679 Controllers with Single Mode Firmware.
680 */
682 static void DAC960_PG_QueueCommandSingleMode(DAC960_Command_T *Command)
683 {
684 DAC960_Controller_T *Controller = Command->Controller;
685 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
686 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
687 DAC960_V1_CommandMailbox_T *NextCommandMailbox =
688 Controller->V1.NextCommandMailbox;
689 CommandMailbox->Common.CommandIdentifier = Command->CommandIdentifier;
690 DAC960_PG_WriteCommandMailbox(NextCommandMailbox, CommandMailbox);
691 if (Controller->V1.PreviousCommandMailbox1->Words[0] == 0 ||
692 Controller->V1.PreviousCommandMailbox2->Words[0] == 0)
693 DAC960_PG_HardwareMailboxNewCommand(ControllerBaseAddress);
694 Controller->V1.PreviousCommandMailbox2 =
695 Controller->V1.PreviousCommandMailbox1;
696 Controller->V1.PreviousCommandMailbox1 = NextCommandMailbox;
697 if (++NextCommandMailbox > Controller->V1.LastCommandMailbox)
698 NextCommandMailbox = Controller->V1.FirstCommandMailbox;
699 Controller->V1.NextCommandMailbox = NextCommandMailbox;
700 }
703 /*
704 DAC960_PD_QueueCommand queues Command for DAC960 PD Series Controllers.
705 */
707 static void DAC960_PD_QueueCommand(DAC960_Command_T *Command)
708 {
709 DAC960_Controller_T *Controller = Command->Controller;
710 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
711 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
712 CommandMailbox->Common.CommandIdentifier = Command->CommandIdentifier;
713 while (DAC960_PD_MailboxFullP(ControllerBaseAddress))
714 udelay(1);
715 DAC960_PD_WriteCommandMailbox(ControllerBaseAddress, CommandMailbox);
716 DAC960_PD_NewCommand(ControllerBaseAddress);
717 }
720 /*
721 DAC960_P_QueueCommand queues Command for DAC960 P Series Controllers.
722 */
724 static void DAC960_P_QueueCommand(DAC960_Command_T *Command)
725 {
726 DAC960_Controller_T *Controller = Command->Controller;
727 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
728 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
729 CommandMailbox->Common.CommandIdentifier = Command->CommandIdentifier;
730 switch (CommandMailbox->Common.CommandOpcode)
731 {
732 case DAC960_V1_Enquiry:
733 CommandMailbox->Common.CommandOpcode = DAC960_V1_Enquiry_Old;
734 break;
735 case DAC960_V1_GetDeviceState:
736 CommandMailbox->Common.CommandOpcode = DAC960_V1_GetDeviceState_Old;
737 break;
738 case DAC960_V1_Read:
739 CommandMailbox->Common.CommandOpcode = DAC960_V1_Read_Old;
740 DAC960_PD_To_P_TranslateReadWriteCommand(CommandMailbox);
741 break;
742 case DAC960_V1_Write:
743 CommandMailbox->Common.CommandOpcode = DAC960_V1_Write_Old;
744 DAC960_PD_To_P_TranslateReadWriteCommand(CommandMailbox);
745 break;
746 case DAC960_V1_ReadWithScatterGather:
747 CommandMailbox->Common.CommandOpcode =
748 DAC960_V1_ReadWithScatterGather_Old;
749 DAC960_PD_To_P_TranslateReadWriteCommand(CommandMailbox);
750 break;
751 case DAC960_V1_WriteWithScatterGather:
752 CommandMailbox->Common.CommandOpcode =
753 DAC960_V1_WriteWithScatterGather_Old;
754 DAC960_PD_To_P_TranslateReadWriteCommand(CommandMailbox);
755 break;
756 default:
757 break;
758 }
759 while (DAC960_PD_MailboxFullP(ControllerBaseAddress))
760 udelay(1);
761 DAC960_PD_WriteCommandMailbox(ControllerBaseAddress, CommandMailbox);
762 DAC960_PD_NewCommand(ControllerBaseAddress);
763 }
766 /*
767 DAC960_ExecuteCommand executes Command and waits for completion.
768 */
770 static void DAC960_ExecuteCommand(DAC960_Command_T *Command)
771 {
772 DAC960_Controller_T *Controller = Command->Controller;
773 DECLARE_COMPLETION(Completion);
774 unsigned long flags;
775 Command->Completion = &Completion;
777 spin_lock_irqsave(&Controller->queue_lock, flags);
778 DAC960_QueueCommand(Command);
779 spin_unlock_irqrestore(&Controller->queue_lock, flags);
781 if (in_interrupt())
782 return;
783 wait_for_completion(&Completion);
784 }
787 /*
788 DAC960_V1_ExecuteType3 executes a DAC960 V1 Firmware Controller Type 3
789 Command and waits for completion. It returns true on success and false
790 on failure.
791 */
793 static boolean DAC960_V1_ExecuteType3(DAC960_Controller_T *Controller,
794 DAC960_V1_CommandOpcode_T CommandOpcode,
795 dma_addr_t DataDMA)
796 {
797 DAC960_Command_T *Command = DAC960_AllocateCommand(Controller);
798 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
799 DAC960_V1_CommandStatus_T CommandStatus;
800 DAC960_V1_ClearCommand(Command);
801 Command->CommandType = DAC960_ImmediateCommand;
802 CommandMailbox->Type3.CommandOpcode = CommandOpcode;
803 CommandMailbox->Type3.BusAddress = DataDMA;
804 DAC960_ExecuteCommand(Command);
805 CommandStatus = Command->V1.CommandStatus;
806 DAC960_DeallocateCommand(Command);
807 return (CommandStatus == DAC960_V1_NormalCompletion);
808 }
811 /*
812 DAC960_V1_ExecuteTypeB executes a DAC960 V1 Firmware Controller Type 3B
813 Command and waits for completion. It returns true on success and false
814 on failure.
815 */
817 static boolean DAC960_V1_ExecuteType3B(DAC960_Controller_T *Controller,
818 DAC960_V1_CommandOpcode_T CommandOpcode,
819 unsigned char CommandOpcode2,
820 dma_addr_t DataDMA)
821 {
822 DAC960_Command_T *Command = DAC960_AllocateCommand(Controller);
823 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
824 DAC960_V1_CommandStatus_T CommandStatus;
825 DAC960_V1_ClearCommand(Command);
826 Command->CommandType = DAC960_ImmediateCommand;
827 CommandMailbox->Type3B.CommandOpcode = CommandOpcode;
828 CommandMailbox->Type3B.CommandOpcode2 = CommandOpcode2;
829 CommandMailbox->Type3B.BusAddress = DataDMA;
830 DAC960_ExecuteCommand(Command);
831 CommandStatus = Command->V1.CommandStatus;
832 DAC960_DeallocateCommand(Command);
833 return (CommandStatus == DAC960_V1_NormalCompletion);
834 }
837 /*
838 DAC960_V1_ExecuteType3D executes a DAC960 V1 Firmware Controller Type 3D
839 Command and waits for completion. It returns true on success and false
840 on failure.
841 */
843 static boolean DAC960_V1_ExecuteType3D(DAC960_Controller_T *Controller,
844 DAC960_V1_CommandOpcode_T CommandOpcode,
845 unsigned char Channel,
846 unsigned char TargetID,
847 dma_addr_t DataDMA)
848 {
849 DAC960_Command_T *Command = DAC960_AllocateCommand(Controller);
850 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
851 DAC960_V1_CommandStatus_T CommandStatus;
852 DAC960_V1_ClearCommand(Command);
853 Command->CommandType = DAC960_ImmediateCommand;
854 CommandMailbox->Type3D.CommandOpcode = CommandOpcode;
855 CommandMailbox->Type3D.Channel = Channel;
856 CommandMailbox->Type3D.TargetID = TargetID;
857 CommandMailbox->Type3D.BusAddress = DataDMA;
858 DAC960_ExecuteCommand(Command);
859 CommandStatus = Command->V1.CommandStatus;
860 DAC960_DeallocateCommand(Command);
861 return (CommandStatus == DAC960_V1_NormalCompletion);
862 }
865 /*
866 DAC960_V2_GeneralInfo executes a DAC960 V2 Firmware General Information
867 Reading IOCTL Command and waits for completion. It returns true on success
868 and false on failure.
870 Return data in The controller's HealthStatusBuffer, which is dma-able memory
871 */
873 static boolean DAC960_V2_GeneralInfo(DAC960_Controller_T *Controller)
874 {
875 DAC960_Command_T *Command = DAC960_AllocateCommand(Controller);
876 DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
877 DAC960_V2_CommandStatus_T CommandStatus;
878 DAC960_V2_ClearCommand(Command);
879 Command->CommandType = DAC960_ImmediateCommand;
880 CommandMailbox->Common.CommandOpcode = DAC960_V2_IOCTL;
881 CommandMailbox->Common.CommandControlBits
882 .DataTransferControllerToHost = true;
883 CommandMailbox->Common.CommandControlBits
884 .NoAutoRequestSense = true;
885 CommandMailbox->Common.DataTransferSize = sizeof(DAC960_V2_HealthStatusBuffer_T);
886 CommandMailbox->Common.IOCTL_Opcode = DAC960_V2_GetHealthStatus;
887 CommandMailbox->Common.DataTransferMemoryAddress
888 .ScatterGatherSegments[0]
889 .SegmentDataPointer =
890 Controller->V2.HealthStatusBufferDMA;
891 CommandMailbox->Common.DataTransferMemoryAddress
892 .ScatterGatherSegments[0]
893 .SegmentByteCount =
894 CommandMailbox->Common.DataTransferSize;
895 DAC960_ExecuteCommand(Command);
896 CommandStatus = Command->V2.CommandStatus;
897 DAC960_DeallocateCommand(Command);
898 return (CommandStatus == DAC960_V2_NormalCompletion);
899 }
902 /*
903 DAC960_V2_ControllerInfo executes a DAC960 V2 Firmware Controller
904 Information Reading IOCTL Command and waits for completion. It returns
905 true on success and false on failure.
907 Data is returned in the controller's V2.NewControllerInformation dma-able
908 memory buffer.
909 */
911 static boolean DAC960_V2_NewControllerInfo(DAC960_Controller_T *Controller)
912 {
913 DAC960_Command_T *Command = DAC960_AllocateCommand(Controller);
914 DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
915 DAC960_V2_CommandStatus_T CommandStatus;
916 DAC960_V2_ClearCommand(Command);
917 Command->CommandType = DAC960_ImmediateCommand;
918 CommandMailbox->ControllerInfo.CommandOpcode = DAC960_V2_IOCTL;
919 CommandMailbox->ControllerInfo.CommandControlBits
920 .DataTransferControllerToHost = true;
921 CommandMailbox->ControllerInfo.CommandControlBits
922 .NoAutoRequestSense = true;
923 CommandMailbox->ControllerInfo.DataTransferSize = sizeof(DAC960_V2_ControllerInfo_T);
924 CommandMailbox->ControllerInfo.ControllerNumber = 0;
925 CommandMailbox->ControllerInfo.IOCTL_Opcode = DAC960_V2_GetControllerInfo;
926 CommandMailbox->ControllerInfo.DataTransferMemoryAddress
927 .ScatterGatherSegments[0]
928 .SegmentDataPointer =
929 Controller->V2.NewControllerInformationDMA;
930 CommandMailbox->ControllerInfo.DataTransferMemoryAddress
931 .ScatterGatherSegments[0]
932 .SegmentByteCount =
933 CommandMailbox->ControllerInfo.DataTransferSize;
934 DAC960_ExecuteCommand(Command);
935 CommandStatus = Command->V2.CommandStatus;
936 DAC960_DeallocateCommand(Command);
937 return (CommandStatus == DAC960_V2_NormalCompletion);
938 }
941 /*
942 DAC960_V2_LogicalDeviceInfo executes a DAC960 V2 Firmware Controller Logical
943 Device Information Reading IOCTL Command and waits for completion. It
944 returns true on success and false on failure.
946 Data is returned in the controller's V2.NewLogicalDeviceInformation
947 */
949 static boolean DAC960_V2_NewLogicalDeviceInfo(DAC960_Controller_T *Controller,
950 unsigned short LogicalDeviceNumber)
951 {
952 DAC960_Command_T *Command = DAC960_AllocateCommand(Controller);
953 DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
954 DAC960_V2_CommandStatus_T CommandStatus;
956 DAC960_V2_ClearCommand(Command);
957 Command->CommandType = DAC960_ImmediateCommand;
958 CommandMailbox->LogicalDeviceInfo.CommandOpcode =
959 DAC960_V2_IOCTL;
960 CommandMailbox->LogicalDeviceInfo.CommandControlBits
961 .DataTransferControllerToHost = true;
962 CommandMailbox->LogicalDeviceInfo.CommandControlBits
963 .NoAutoRequestSense = true;
964 CommandMailbox->LogicalDeviceInfo.DataTransferSize =
965 sizeof(DAC960_V2_LogicalDeviceInfo_T);
966 CommandMailbox->LogicalDeviceInfo.LogicalDevice.LogicalDeviceNumber =
967 LogicalDeviceNumber;
968 CommandMailbox->LogicalDeviceInfo.IOCTL_Opcode = DAC960_V2_GetLogicalDeviceInfoValid;
969 CommandMailbox->LogicalDeviceInfo.DataTransferMemoryAddress
970 .ScatterGatherSegments[0]
971 .SegmentDataPointer =
972 Controller->V2.NewLogicalDeviceInformationDMA;
973 CommandMailbox->LogicalDeviceInfo.DataTransferMemoryAddress
974 .ScatterGatherSegments[0]
975 .SegmentByteCount =
976 CommandMailbox->LogicalDeviceInfo.DataTransferSize;
977 DAC960_ExecuteCommand(Command);
978 CommandStatus = Command->V2.CommandStatus;
979 DAC960_DeallocateCommand(Command);
980 return (CommandStatus == DAC960_V2_NormalCompletion);
981 }
984 /*
985 DAC960_V2_PhysicalDeviceInfo executes a DAC960 V2 Firmware Controller "Read
986 Physical Device Information" IOCTL Command and waits for completion. It
987 returns true on success and false on failure.
989 The Channel, TargetID, LogicalUnit arguments should be 0 the first time
990 this function is called for a given controller. This will return data
991 for the "first" device on that controller. The returned data includes a
992 Channel, TargetID, LogicalUnit that can be passed in to this routine to
993 get data for the NEXT device on that controller.
995 Data is stored in the controller's V2.NewPhysicalDeviceInfo dma-able
996 memory buffer.
998 */
1000 static boolean DAC960_V2_NewPhysicalDeviceInfo(DAC960_Controller_T *Controller,
1001 unsigned char Channel,
1002 unsigned char TargetID,
1003 unsigned char LogicalUnit)
1005 DAC960_Command_T *Command = DAC960_AllocateCommand(Controller);
1006 DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
1007 DAC960_V2_CommandStatus_T CommandStatus;
1009 DAC960_V2_ClearCommand(Command);
1010 Command->CommandType = DAC960_ImmediateCommand;
1011 CommandMailbox->PhysicalDeviceInfo.CommandOpcode = DAC960_V2_IOCTL;
1012 CommandMailbox->PhysicalDeviceInfo.CommandControlBits
1013 .DataTransferControllerToHost = true;
1014 CommandMailbox->PhysicalDeviceInfo.CommandControlBits
1015 .NoAutoRequestSense = true;
1016 CommandMailbox->PhysicalDeviceInfo.DataTransferSize =
1017 sizeof(DAC960_V2_PhysicalDeviceInfo_T);
1018 CommandMailbox->PhysicalDeviceInfo.PhysicalDevice.LogicalUnit = LogicalUnit;
1019 CommandMailbox->PhysicalDeviceInfo.PhysicalDevice.TargetID = TargetID;
1020 CommandMailbox->PhysicalDeviceInfo.PhysicalDevice.Channel = Channel;
1021 CommandMailbox->PhysicalDeviceInfo.IOCTL_Opcode =
1022 DAC960_V2_GetPhysicalDeviceInfoValid;
1023 CommandMailbox->PhysicalDeviceInfo.DataTransferMemoryAddress
1024 .ScatterGatherSegments[0]
1025 .SegmentDataPointer =
1026 Controller->V2.NewPhysicalDeviceInformationDMA;
1027 CommandMailbox->PhysicalDeviceInfo.DataTransferMemoryAddress
1028 .ScatterGatherSegments[0]
1029 .SegmentByteCount =
1030 CommandMailbox->PhysicalDeviceInfo.DataTransferSize;
1031 DAC960_ExecuteCommand(Command);
1032 CommandStatus = Command->V2.CommandStatus;
1033 DAC960_DeallocateCommand(Command);
1034 return (CommandStatus == DAC960_V2_NormalCompletion);
1038 static void DAC960_V2_ConstructNewUnitSerialNumber(
1039 DAC960_Controller_T *Controller,
1040 DAC960_V2_CommandMailbox_T *CommandMailbox, int Channel, int TargetID,
1041 int LogicalUnit)
1043 CommandMailbox->SCSI_10.CommandOpcode = DAC960_V2_SCSI_10_Passthru;
1044 CommandMailbox->SCSI_10.CommandControlBits
1045 .DataTransferControllerToHost = true;
1046 CommandMailbox->SCSI_10.CommandControlBits
1047 .NoAutoRequestSense = true;
1048 CommandMailbox->SCSI_10.DataTransferSize =
1049 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T);
1050 CommandMailbox->SCSI_10.PhysicalDevice.LogicalUnit = LogicalUnit;
1051 CommandMailbox->SCSI_10.PhysicalDevice.TargetID = TargetID;
1052 CommandMailbox->SCSI_10.PhysicalDevice.Channel = Channel;
1053 CommandMailbox->SCSI_10.CDBLength = 6;
1054 CommandMailbox->SCSI_10.SCSI_CDB[0] = 0x12; /* INQUIRY */
1055 CommandMailbox->SCSI_10.SCSI_CDB[1] = 1; /* EVPD = 1 */
1056 CommandMailbox->SCSI_10.SCSI_CDB[2] = 0x80; /* Page Code */
1057 CommandMailbox->SCSI_10.SCSI_CDB[3] = 0; /* Reserved */
1058 CommandMailbox->SCSI_10.SCSI_CDB[4] =
1059 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T);
1060 CommandMailbox->SCSI_10.SCSI_CDB[5] = 0; /* Control */
1061 CommandMailbox->SCSI_10.DataTransferMemoryAddress
1062 .ScatterGatherSegments[0]
1063 .SegmentDataPointer =
1064 Controller->V2.NewInquiryUnitSerialNumberDMA;
1065 CommandMailbox->SCSI_10.DataTransferMemoryAddress
1066 .ScatterGatherSegments[0]
1067 .SegmentByteCount =
1068 CommandMailbox->SCSI_10.DataTransferSize;
1072 /*
1073 DAC960_V2_NewUnitSerialNumber executes an SCSI pass-through
1074 Inquiry command to a SCSI device identified by Channel number,
1075 Target id, Logical Unit Number. This function Waits for completion
1076 of the command.
1078 The return data includes Unit Serial Number information for the
1079 specified device.
1081 Data is stored in the controller's V2.NewPhysicalDeviceInfo dma-able
1082 memory buffer.
1083 */
1085 static boolean DAC960_V2_NewInquiryUnitSerialNumber(DAC960_Controller_T *Controller,
1086 int Channel, int TargetID, int LogicalUnit)
1088 DAC960_Command_T *Command;
1089 DAC960_V2_CommandMailbox_T *CommandMailbox;
1090 DAC960_V2_CommandStatus_T CommandStatus;
1092 Command = DAC960_AllocateCommand(Controller);
1093 CommandMailbox = &Command->V2.CommandMailbox;
1094 DAC960_V2_ClearCommand(Command);
1095 Command->CommandType = DAC960_ImmediateCommand;
1097 DAC960_V2_ConstructNewUnitSerialNumber(Controller, CommandMailbox,
1098 Channel, TargetID, LogicalUnit);
1100 DAC960_ExecuteCommand(Command);
1101 CommandStatus = Command->V2.CommandStatus;
1102 DAC960_DeallocateCommand(Command);
1103 return (CommandStatus == DAC960_V2_NormalCompletion);
1107 /*
1108 DAC960_V2_DeviceOperation executes a DAC960 V2 Firmware Controller Device
1109 Operation IOCTL Command and waits for completion. It returns true on
1110 success and false on failure.
1111 */
1113 static boolean DAC960_V2_DeviceOperation(DAC960_Controller_T *Controller,
1114 DAC960_V2_IOCTL_Opcode_T IOCTL_Opcode,
1115 DAC960_V2_OperationDevice_T
1116 OperationDevice)
1118 DAC960_Command_T *Command = DAC960_AllocateCommand(Controller);
1119 DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
1120 DAC960_V2_CommandStatus_T CommandStatus;
1121 DAC960_V2_ClearCommand(Command);
1122 Command->CommandType = DAC960_ImmediateCommand;
1123 CommandMailbox->DeviceOperation.CommandOpcode = DAC960_V2_IOCTL;
1124 CommandMailbox->DeviceOperation.CommandControlBits
1125 .DataTransferControllerToHost = true;
1126 CommandMailbox->DeviceOperation.CommandControlBits
1127 .NoAutoRequestSense = true;
1128 CommandMailbox->DeviceOperation.IOCTL_Opcode = IOCTL_Opcode;
1129 CommandMailbox->DeviceOperation.OperationDevice = OperationDevice;
1130 DAC960_ExecuteCommand(Command);
1131 CommandStatus = Command->V2.CommandStatus;
1132 DAC960_DeallocateCommand(Command);
1133 return (CommandStatus == DAC960_V2_NormalCompletion);
1137 /*
1138 DAC960_V1_EnableMemoryMailboxInterface enables the Memory Mailbox Interface
1139 for DAC960 V1 Firmware Controllers.
1141 PD and P controller types have no memory mailbox, but still need the
1142 other dma mapped memory.
1143 */
1145 static boolean DAC960_V1_EnableMemoryMailboxInterface(DAC960_Controller_T
1146 *Controller)
1148 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
1149 DAC960_HardwareType_T hw_type = Controller->HardwareType;
1150 struct pci_dev *PCI_Device = Controller->PCIDevice;
1151 struct dma_loaf *DmaPages = &Controller->DmaPages;
1152 size_t DmaPagesSize;
1153 size_t CommandMailboxesSize;
1154 size_t StatusMailboxesSize;
1156 DAC960_V1_CommandMailbox_T *CommandMailboxesMemory;
1157 dma_addr_t CommandMailboxesMemoryDMA;
1159 DAC960_V1_StatusMailbox_T *StatusMailboxesMemory;
1160 dma_addr_t StatusMailboxesMemoryDMA;
1162 DAC960_V1_CommandMailbox_T CommandMailbox;
1163 DAC960_V1_CommandStatus_T CommandStatus;
1164 int TimeoutCounter;
1165 int i;
1168 if (pci_set_dma_mask(Controller->PCIDevice, DAC690_V1_PciDmaMask))
1169 return DAC960_Failure(Controller, "DMA mask out of range");
1170 Controller->BounceBufferLimit = DAC690_V1_PciDmaMask;
1172 if ((hw_type == DAC960_PD_Controller) || (hw_type == DAC960_P_Controller)) {
1173 CommandMailboxesSize = 0;
1174 StatusMailboxesSize = 0;
1175 } else {
1176 CommandMailboxesSize = DAC960_V1_CommandMailboxCount * sizeof(DAC960_V1_CommandMailbox_T);
1177 StatusMailboxesSize = DAC960_V1_StatusMailboxCount * sizeof(DAC960_V1_StatusMailbox_T);
1179 DmaPagesSize = CommandMailboxesSize + StatusMailboxesSize +
1180 sizeof(DAC960_V1_DCDB_T) + sizeof(DAC960_V1_Enquiry_T) +
1181 sizeof(DAC960_V1_ErrorTable_T) + sizeof(DAC960_V1_EventLogEntry_T) +
1182 sizeof(DAC960_V1_RebuildProgress_T) +
1183 sizeof(DAC960_V1_LogicalDriveInformationArray_T) +
1184 sizeof(DAC960_V1_BackgroundInitializationStatus_T) +
1185 sizeof(DAC960_V1_DeviceState_T) + sizeof(DAC960_SCSI_Inquiry_T) +
1186 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T);
1188 if (!init_dma_loaf(PCI_Device, DmaPages, DmaPagesSize))
1189 return false;
1192 if ((hw_type == DAC960_PD_Controller) || (hw_type == DAC960_P_Controller))
1193 goto skip_mailboxes;
1195 CommandMailboxesMemory = slice_dma_loaf(DmaPages,
1196 CommandMailboxesSize, &CommandMailboxesMemoryDMA);
1198 /* These are the base addresses for the command memory mailbox array */
1199 Controller->V1.FirstCommandMailbox = CommandMailboxesMemory;
1200 Controller->V1.FirstCommandMailboxDMA = CommandMailboxesMemoryDMA;
1202 CommandMailboxesMemory += DAC960_V1_CommandMailboxCount - 1;
1203 Controller->V1.LastCommandMailbox = CommandMailboxesMemory;
1204 Controller->V1.NextCommandMailbox = Controller->V1.FirstCommandMailbox;
1205 Controller->V1.PreviousCommandMailbox1 = Controller->V1.LastCommandMailbox;
1206 Controller->V1.PreviousCommandMailbox2 =
1207 Controller->V1.LastCommandMailbox - 1;
1209 /* These are the base addresses for the status memory mailbox array */
1210 StatusMailboxesMemory = slice_dma_loaf(DmaPages,
1211 StatusMailboxesSize, &StatusMailboxesMemoryDMA);
1213 Controller->V1.FirstStatusMailbox = StatusMailboxesMemory;
1214 Controller->V1.FirstStatusMailboxDMA = StatusMailboxesMemoryDMA;
1215 StatusMailboxesMemory += DAC960_V1_StatusMailboxCount - 1;
1216 Controller->V1.LastStatusMailbox = StatusMailboxesMemory;
1217 Controller->V1.NextStatusMailbox = Controller->V1.FirstStatusMailbox;
1219 skip_mailboxes:
1220 Controller->V1.MonitoringDCDB = slice_dma_loaf(DmaPages,
1221 sizeof(DAC960_V1_DCDB_T),
1222 &Controller->V1.MonitoringDCDB_DMA);
1224 Controller->V1.NewEnquiry = slice_dma_loaf(DmaPages,
1225 sizeof(DAC960_V1_Enquiry_T),
1226 &Controller->V1.NewEnquiryDMA);
1228 Controller->V1.NewErrorTable = slice_dma_loaf(DmaPages,
1229 sizeof(DAC960_V1_ErrorTable_T),
1230 &Controller->V1.NewErrorTableDMA);
1232 Controller->V1.EventLogEntry = slice_dma_loaf(DmaPages,
1233 sizeof(DAC960_V1_EventLogEntry_T),
1234 &Controller->V1.EventLogEntryDMA);
1236 Controller->V1.RebuildProgress = slice_dma_loaf(DmaPages,
1237 sizeof(DAC960_V1_RebuildProgress_T),
1238 &Controller->V1.RebuildProgressDMA);
1240 Controller->V1.NewLogicalDriveInformation = slice_dma_loaf(DmaPages,
1241 sizeof(DAC960_V1_LogicalDriveInformationArray_T),
1242 &Controller->V1.NewLogicalDriveInformationDMA);
1244 Controller->V1.BackgroundInitializationStatus = slice_dma_loaf(DmaPages,
1245 sizeof(DAC960_V1_BackgroundInitializationStatus_T),
1246 &Controller->V1.BackgroundInitializationStatusDMA);
1248 Controller->V1.NewDeviceState = slice_dma_loaf(DmaPages,
1249 sizeof(DAC960_V1_DeviceState_T),
1250 &Controller->V1.NewDeviceStateDMA);
1252 Controller->V1.NewInquiryStandardData = slice_dma_loaf(DmaPages,
1253 sizeof(DAC960_SCSI_Inquiry_T),
1254 &Controller->V1.NewInquiryStandardDataDMA);
1256 Controller->V1.NewInquiryUnitSerialNumber = slice_dma_loaf(DmaPages,
1257 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T),
1258 &Controller->V1.NewInquiryUnitSerialNumberDMA);
1260 if ((hw_type == DAC960_PD_Controller) || (hw_type == DAC960_P_Controller))
1261 return true;
1263 /* Enable the Memory Mailbox Interface. */
1264 Controller->V1.DualModeMemoryMailboxInterface = true;
1265 CommandMailbox.TypeX.CommandOpcode = 0x2B;
1266 CommandMailbox.TypeX.CommandIdentifier = 0;
1267 CommandMailbox.TypeX.CommandOpcode2 = 0x14;
1268 CommandMailbox.TypeX.CommandMailboxesBusAddress =
1269 Controller->V1.FirstCommandMailboxDMA;
1270 CommandMailbox.TypeX.StatusMailboxesBusAddress =
1271 Controller->V1.FirstStatusMailboxDMA;
1272 #define TIMEOUT_COUNT 1000000
1274 for (i = 0; i < 2; i++)
1275 switch (Controller->HardwareType)
1277 case DAC960_LA_Controller:
1278 TimeoutCounter = TIMEOUT_COUNT;
1279 while (--TimeoutCounter >= 0)
1281 if (!DAC960_LA_HardwareMailboxFullP(ControllerBaseAddress))
1282 break;
1283 udelay(10);
1285 if (TimeoutCounter < 0) return false;
1286 DAC960_LA_WriteHardwareMailbox(ControllerBaseAddress, &CommandMailbox);
1287 DAC960_LA_HardwareMailboxNewCommand(ControllerBaseAddress);
1288 TimeoutCounter = TIMEOUT_COUNT;
1289 while (--TimeoutCounter >= 0)
1291 if (DAC960_LA_HardwareMailboxStatusAvailableP(
1292 ControllerBaseAddress))
1293 break;
1294 udelay(10);
1296 if (TimeoutCounter < 0) return false;
1297 CommandStatus = DAC960_LA_ReadStatusRegister(ControllerBaseAddress);
1298 DAC960_LA_AcknowledgeHardwareMailboxInterrupt(ControllerBaseAddress);
1299 DAC960_LA_AcknowledgeHardwareMailboxStatus(ControllerBaseAddress);
1300 if (CommandStatus == DAC960_V1_NormalCompletion) return true;
1301 Controller->V1.DualModeMemoryMailboxInterface = false;
1302 CommandMailbox.TypeX.CommandOpcode2 = 0x10;
1303 break;
1304 case DAC960_PG_Controller:
1305 TimeoutCounter = TIMEOUT_COUNT;
1306 while (--TimeoutCounter >= 0)
1308 if (!DAC960_PG_HardwareMailboxFullP(ControllerBaseAddress))
1309 break;
1310 udelay(10);
1312 if (TimeoutCounter < 0) return false;
1313 DAC960_PG_WriteHardwareMailbox(ControllerBaseAddress, &CommandMailbox);
1314 DAC960_PG_HardwareMailboxNewCommand(ControllerBaseAddress);
1316 TimeoutCounter = TIMEOUT_COUNT;
1317 while (--TimeoutCounter >= 0)
1319 if (DAC960_PG_HardwareMailboxStatusAvailableP(
1320 ControllerBaseAddress))
1321 break;
1322 udelay(10);
1324 if (TimeoutCounter < 0) return false;
1325 CommandStatus = DAC960_PG_ReadStatusRegister(ControllerBaseAddress);
1326 DAC960_PG_AcknowledgeHardwareMailboxInterrupt(ControllerBaseAddress);
1327 DAC960_PG_AcknowledgeHardwareMailboxStatus(ControllerBaseAddress);
1328 if (CommandStatus == DAC960_V1_NormalCompletion) return true;
1329 Controller->V1.DualModeMemoryMailboxInterface = false;
1330 CommandMailbox.TypeX.CommandOpcode2 = 0x10;
1331 break;
1332 default:
1333 DAC960_Failure(Controller, "Unknown Controller Type\n");
1334 break;
1336 return false;
1340 /*
1341 DAC960_V2_EnableMemoryMailboxInterface enables the Memory Mailbox Interface
1342 for DAC960 V2 Firmware Controllers.
1344 Aggregate the space needed for the controller's memory mailbox and
1345 the other data structures that will be targets of dma transfers with
1346 the controller. Allocate a dma-mapped region of memory to hold these
1347 structures. Then, save CPU pointers and dma_addr_t values to reference
1348 the structures that are contained in that region.
1349 */
1351 static boolean DAC960_V2_EnableMemoryMailboxInterface(DAC960_Controller_T
1352 *Controller)
1354 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
1355 struct pci_dev *PCI_Device = Controller->PCIDevice;
1356 struct dma_loaf *DmaPages = &Controller->DmaPages;
1357 size_t DmaPagesSize;
1358 size_t CommandMailboxesSize;
1359 size_t StatusMailboxesSize;
1361 DAC960_V2_CommandMailbox_T *CommandMailboxesMemory;
1362 dma_addr_t CommandMailboxesMemoryDMA;
1364 DAC960_V2_StatusMailbox_T *StatusMailboxesMemory;
1365 dma_addr_t StatusMailboxesMemoryDMA;
1367 DAC960_V2_CommandMailbox_T *CommandMailbox;
1368 dma_addr_t CommandMailboxDMA;
1369 DAC960_V2_CommandStatus_T CommandStatus;
1371 if (pci_set_dma_mask(Controller->PCIDevice, DAC690_V2_PciDmaMask))
1372 return DAC960_Failure(Controller, "DMA mask out of range");
1373 Controller->BounceBufferLimit = DAC690_V2_PciDmaMask;
1375 /* This is a temporary dma mapping, used only in the scope of this function */
1376 CommandMailbox =
1377 (DAC960_V2_CommandMailbox_T *)pci_alloc_consistent( PCI_Device,
1378 sizeof(DAC960_V2_CommandMailbox_T), &CommandMailboxDMA);
1379 if (CommandMailbox == NULL)
1380 return false;
1382 CommandMailboxesSize = DAC960_V2_CommandMailboxCount * sizeof(DAC960_V2_CommandMailbox_T);
1383 StatusMailboxesSize = DAC960_V2_StatusMailboxCount * sizeof(DAC960_V2_StatusMailbox_T);
1384 DmaPagesSize =
1385 CommandMailboxesSize + StatusMailboxesSize +
1386 sizeof(DAC960_V2_HealthStatusBuffer_T) +
1387 sizeof(DAC960_V2_ControllerInfo_T) +
1388 sizeof(DAC960_V2_LogicalDeviceInfo_T) +
1389 sizeof(DAC960_V2_PhysicalDeviceInfo_T) +
1390 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T) +
1391 sizeof(DAC960_V2_Event_T) +
1392 sizeof(DAC960_V2_PhysicalToLogicalDevice_T);
1394 if (!init_dma_loaf(PCI_Device, DmaPages, DmaPagesSize)) {
1395 pci_free_consistent(PCI_Device, sizeof(DAC960_V2_CommandMailbox_T),
1396 CommandMailbox, CommandMailboxDMA);
1397 return false;
1400 CommandMailboxesMemory = slice_dma_loaf(DmaPages,
1401 CommandMailboxesSize, &CommandMailboxesMemoryDMA);
1403 /* These are the base addresses for the command memory mailbox array */
1404 Controller->V2.FirstCommandMailbox = CommandMailboxesMemory;
1405 Controller->V2.FirstCommandMailboxDMA = CommandMailboxesMemoryDMA;
1407 CommandMailboxesMemory += DAC960_V2_CommandMailboxCount - 1;
1408 Controller->V2.LastCommandMailbox = CommandMailboxesMemory;
1409 Controller->V2.NextCommandMailbox = Controller->V2.FirstCommandMailbox;
1410 Controller->V2.PreviousCommandMailbox1 = Controller->V2.LastCommandMailbox;
1411 Controller->V2.PreviousCommandMailbox2 =
1412 Controller->V2.LastCommandMailbox - 1;
1414 /* These are the base addresses for the status memory mailbox array */
1415 StatusMailboxesMemory = slice_dma_loaf(DmaPages,
1416 StatusMailboxesSize, &StatusMailboxesMemoryDMA);
1418 Controller->V2.FirstStatusMailbox = StatusMailboxesMemory;
1419 Controller->V2.FirstStatusMailboxDMA = StatusMailboxesMemoryDMA;
1420 StatusMailboxesMemory += DAC960_V2_StatusMailboxCount - 1;
1421 Controller->V2.LastStatusMailbox = StatusMailboxesMemory;
1422 Controller->V2.NextStatusMailbox = Controller->V2.FirstStatusMailbox;
1424 Controller->V2.HealthStatusBuffer = slice_dma_loaf(DmaPages,
1425 sizeof(DAC960_V2_HealthStatusBuffer_T),
1426 &Controller->V2.HealthStatusBufferDMA);
1428 Controller->V2.NewControllerInformation = slice_dma_loaf(DmaPages,
1429 sizeof(DAC960_V2_ControllerInfo_T),
1430 &Controller->V2.NewControllerInformationDMA);
1432 Controller->V2.NewLogicalDeviceInformation = slice_dma_loaf(DmaPages,
1433 sizeof(DAC960_V2_LogicalDeviceInfo_T),
1434 &Controller->V2.NewLogicalDeviceInformationDMA);
1436 Controller->V2.NewPhysicalDeviceInformation = slice_dma_loaf(DmaPages,
1437 sizeof(DAC960_V2_PhysicalDeviceInfo_T),
1438 &Controller->V2.NewPhysicalDeviceInformationDMA);
1440 Controller->V2.NewInquiryUnitSerialNumber = slice_dma_loaf(DmaPages,
1441 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T),
1442 &Controller->V2.NewInquiryUnitSerialNumberDMA);
1444 Controller->V2.Event = slice_dma_loaf(DmaPages,
1445 sizeof(DAC960_V2_Event_T),
1446 &Controller->V2.EventDMA);
1448 Controller->V2.PhysicalToLogicalDevice = slice_dma_loaf(DmaPages,
1449 sizeof(DAC960_V2_PhysicalToLogicalDevice_T),
1450 &Controller->V2.PhysicalToLogicalDeviceDMA);
1452 /*
1453 Enable the Memory Mailbox Interface.
1455 I don't know why we can't just use one of the memory mailboxes
1456 we just allocated to do this, instead of using this temporary one.
1457 Try this change later.
1458 */
1459 memset(CommandMailbox, 0, sizeof(DAC960_V2_CommandMailbox_T));
1460 CommandMailbox->SetMemoryMailbox.CommandIdentifier = 1;
1461 CommandMailbox->SetMemoryMailbox.CommandOpcode = DAC960_V2_IOCTL;
1462 CommandMailbox->SetMemoryMailbox.CommandControlBits.NoAutoRequestSense = true;
1463 CommandMailbox->SetMemoryMailbox.FirstCommandMailboxSizeKB =
1464 (DAC960_V2_CommandMailboxCount * sizeof(DAC960_V2_CommandMailbox_T)) >> 10;
1465 CommandMailbox->SetMemoryMailbox.FirstStatusMailboxSizeKB =
1466 (DAC960_V2_StatusMailboxCount * sizeof(DAC960_V2_StatusMailbox_T)) >> 10;
1467 CommandMailbox->SetMemoryMailbox.SecondCommandMailboxSizeKB = 0;
1468 CommandMailbox->SetMemoryMailbox.SecondStatusMailboxSizeKB = 0;
1469 CommandMailbox->SetMemoryMailbox.RequestSenseSize = 0;
1470 CommandMailbox->SetMemoryMailbox.IOCTL_Opcode = DAC960_V2_SetMemoryMailbox;
1471 CommandMailbox->SetMemoryMailbox.HealthStatusBufferSizeKB = 1;
1472 CommandMailbox->SetMemoryMailbox.HealthStatusBufferBusAddress =
1473 Controller->V2.HealthStatusBufferDMA;
1474 CommandMailbox->SetMemoryMailbox.FirstCommandMailboxBusAddress =
1475 Controller->V2.FirstCommandMailboxDMA;
1476 CommandMailbox->SetMemoryMailbox.FirstStatusMailboxBusAddress =
1477 Controller->V2.FirstStatusMailboxDMA;
1478 switch (Controller->HardwareType)
1480 case DAC960_GEM_Controller:
1481 while (DAC960_GEM_HardwareMailboxFullP(ControllerBaseAddress))
1482 udelay(1);
1483 DAC960_GEM_WriteHardwareMailbox(ControllerBaseAddress, CommandMailboxDMA);
1484 DAC960_GEM_HardwareMailboxNewCommand(ControllerBaseAddress);
1485 while (!DAC960_GEM_HardwareMailboxStatusAvailableP(ControllerBaseAddress))
1486 udelay(1);
1487 CommandStatus = DAC960_GEM_ReadCommandStatus(ControllerBaseAddress);
1488 DAC960_GEM_AcknowledgeHardwareMailboxInterrupt(ControllerBaseAddress);
1489 DAC960_GEM_AcknowledgeHardwareMailboxStatus(ControllerBaseAddress);
1490 break;
1491 case DAC960_BA_Controller:
1492 while (DAC960_BA_HardwareMailboxFullP(ControllerBaseAddress))
1493 udelay(1);
1494 DAC960_BA_WriteHardwareMailbox(ControllerBaseAddress, CommandMailboxDMA);
1495 DAC960_BA_HardwareMailboxNewCommand(ControllerBaseAddress);
1496 while (!DAC960_BA_HardwareMailboxStatusAvailableP(ControllerBaseAddress))
1497 udelay(1);
1498 CommandStatus = DAC960_BA_ReadCommandStatus(ControllerBaseAddress);
1499 DAC960_BA_AcknowledgeHardwareMailboxInterrupt(ControllerBaseAddress);
1500 DAC960_BA_AcknowledgeHardwareMailboxStatus(ControllerBaseAddress);
1501 break;
1502 case DAC960_LP_Controller:
1503 while (DAC960_LP_HardwareMailboxFullP(ControllerBaseAddress))
1504 udelay(1);
1505 DAC960_LP_WriteHardwareMailbox(ControllerBaseAddress, CommandMailboxDMA);
1506 DAC960_LP_HardwareMailboxNewCommand(ControllerBaseAddress);
1507 while (!DAC960_LP_HardwareMailboxStatusAvailableP(ControllerBaseAddress))
1508 udelay(1);
1509 CommandStatus = DAC960_LP_ReadCommandStatus(ControllerBaseAddress);
1510 DAC960_LP_AcknowledgeHardwareMailboxInterrupt(ControllerBaseAddress);
1511 DAC960_LP_AcknowledgeHardwareMailboxStatus(ControllerBaseAddress);
1512 break;
1513 default:
1514 DAC960_Failure(Controller, "Unknown Controller Type\n");
1515 CommandStatus = DAC960_V2_AbormalCompletion;
1516 break;
1518 pci_free_consistent(PCI_Device, sizeof(DAC960_V2_CommandMailbox_T),
1519 CommandMailbox, CommandMailboxDMA);
1520 return (CommandStatus == DAC960_V2_NormalCompletion);
1524 /*
1525 DAC960_V1_ReadControllerConfiguration reads the Configuration Information
1526 from DAC960 V1 Firmware Controllers and initializes the Controller structure.
1527 */
1529 static boolean DAC960_V1_ReadControllerConfiguration(DAC960_Controller_T
1530 *Controller)
1532 DAC960_V1_Enquiry2_T *Enquiry2;
1533 dma_addr_t Enquiry2DMA;
1534 DAC960_V1_Config2_T *Config2;
1535 dma_addr_t Config2DMA;
1536 int LogicalDriveNumber, Channel, TargetID;
1537 struct dma_loaf local_dma;
1539 if (!init_dma_loaf(Controller->PCIDevice, &local_dma,
1540 sizeof(DAC960_V1_Enquiry2_T) + sizeof(DAC960_V1_Config2_T)))
1541 return DAC960_Failure(Controller, "LOGICAL DEVICE ALLOCATION");
1543 Enquiry2 = slice_dma_loaf(&local_dma, sizeof(DAC960_V1_Enquiry2_T), &Enquiry2DMA);
1544 Config2 = slice_dma_loaf(&local_dma, sizeof(DAC960_V1_Config2_T), &Config2DMA);
1546 if (!DAC960_V1_ExecuteType3(Controller, DAC960_V1_Enquiry,
1547 Controller->V1.NewEnquiryDMA)) {
1548 free_dma_loaf(Controller->PCIDevice, &local_dma);
1549 return DAC960_Failure(Controller, "ENQUIRY");
1551 memcpy(&Controller->V1.Enquiry, Controller->V1.NewEnquiry,
1552 sizeof(DAC960_V1_Enquiry_T));
1554 if (!DAC960_V1_ExecuteType3(Controller, DAC960_V1_Enquiry2, Enquiry2DMA)) {
1555 free_dma_loaf(Controller->PCIDevice, &local_dma);
1556 return DAC960_Failure(Controller, "ENQUIRY2");
1559 if (!DAC960_V1_ExecuteType3(Controller, DAC960_V1_ReadConfig2, Config2DMA)) {
1560 free_dma_loaf(Controller->PCIDevice, &local_dma);
1561 return DAC960_Failure(Controller, "READ CONFIG2");
1564 if (!DAC960_V1_ExecuteType3(Controller, DAC960_V1_GetLogicalDriveInformation,
1565 Controller->V1.NewLogicalDriveInformationDMA)) {
1566 free_dma_loaf(Controller->PCIDevice, &local_dma);
1567 return DAC960_Failure(Controller, "GET LOGICAL DRIVE INFORMATION");
1569 memcpy(&Controller->V1.LogicalDriveInformation,
1570 Controller->V1.NewLogicalDriveInformation,
1571 sizeof(DAC960_V1_LogicalDriveInformationArray_T));
1573 for (Channel = 0; Channel < Enquiry2->ActualChannels; Channel++)
1574 for (TargetID = 0; TargetID < Enquiry2->MaxTargets; TargetID++) {
1575 if (!DAC960_V1_ExecuteType3D(Controller, DAC960_V1_GetDeviceState,
1576 Channel, TargetID,
1577 Controller->V1.NewDeviceStateDMA)) {
1578 free_dma_loaf(Controller->PCIDevice, &local_dma);
1579 return DAC960_Failure(Controller, "GET DEVICE STATE");
1581 memcpy(&Controller->V1.DeviceState[Channel][TargetID],
1582 Controller->V1.NewDeviceState, sizeof(DAC960_V1_DeviceState_T));
1584 /*
1585 Initialize the Controller Model Name and Full Model Name fields.
1586 */
1587 switch (Enquiry2->HardwareID.SubModel)
1589 case DAC960_V1_P_PD_PU:
1590 if (Enquiry2->SCSICapability.BusSpeed == DAC960_V1_Ultra)
1591 strcpy(Controller->ModelName, "DAC960PU");
1592 else strcpy(Controller->ModelName, "DAC960PD");
1593 break;
1594 case DAC960_V1_PL:
1595 strcpy(Controller->ModelName, "DAC960PL");
1596 break;
1597 case DAC960_V1_PG:
1598 strcpy(Controller->ModelName, "DAC960PG");
1599 break;
1600 case DAC960_V1_PJ:
1601 strcpy(Controller->ModelName, "DAC960PJ");
1602 break;
1603 case DAC960_V1_PR:
1604 strcpy(Controller->ModelName, "DAC960PR");
1605 break;
1606 case DAC960_V1_PT:
1607 strcpy(Controller->ModelName, "DAC960PT");
1608 break;
1609 case DAC960_V1_PTL0:
1610 strcpy(Controller->ModelName, "DAC960PTL0");
1611 break;
1612 case DAC960_V1_PRL:
1613 strcpy(Controller->ModelName, "DAC960PRL");
1614 break;
1615 case DAC960_V1_PTL1:
1616 strcpy(Controller->ModelName, "DAC960PTL1");
1617 break;
1618 case DAC960_V1_1164P:
1619 strcpy(Controller->ModelName, "DAC1164P");
1620 break;
1621 default:
1622 free_dma_loaf(Controller->PCIDevice, &local_dma);
1623 return DAC960_Failure(Controller, "MODEL VERIFICATION");
1625 strcpy(Controller->FullModelName, "Mylex ");
1626 strcat(Controller->FullModelName, Controller->ModelName);
1627 /*
1628 Initialize the Controller Firmware Version field and verify that it
1629 is a supported firmware version. The supported firmware versions are:
1631 DAC1164P 5.06 and above
1632 DAC960PTL/PRL/PJ/PG 4.06 and above
1633 DAC960PU/PD/PL 3.51 and above
1634 DAC960PU/PD/PL/P 2.73 and above
1635 */
1636 #if defined(CONFIG_ALPHA)
1637 /*
1638 DEC Alpha machines were often equipped with DAC960 cards that were
1639 OEMed from Mylex, and had their own custom firmware. Version 2.70,
1640 the last custom FW revision to be released by DEC for these older
1641 controllers, appears to work quite well with this driver.
1643 Cards tested successfully were several versions each of the PD and
1644 PU, called by DEC the KZPSC and KZPAC, respectively, and having
1645 the Manufacturer Numbers (from Mylex), usually on a sticker on the
1646 back of the board, of:
1648 KZPSC: D040347 (1-channel) or D040348 (2-channel) or D040349 (3-channel)
1649 KZPAC: D040395 (1-channel) or D040396 (2-channel) or D040397 (3-channel)
1650 */
1651 # define FIRMWARE_27X "2.70"
1652 #else
1653 # define FIRMWARE_27X "2.73"
1654 #endif
1656 if (Enquiry2->FirmwareID.MajorVersion == 0)
1658 Enquiry2->FirmwareID.MajorVersion =
1659 Controller->V1.Enquiry.MajorFirmwareVersion;
1660 Enquiry2->FirmwareID.MinorVersion =
1661 Controller->V1.Enquiry.MinorFirmwareVersion;
1662 Enquiry2->FirmwareID.FirmwareType = '0';
1663 Enquiry2->FirmwareID.TurnID = 0;
1665 sprintf(Controller->FirmwareVersion, "%d.%02d-%c-%02d",
1666 Enquiry2->FirmwareID.MajorVersion, Enquiry2->FirmwareID.MinorVersion,
1667 Enquiry2->FirmwareID.FirmwareType, Enquiry2->FirmwareID.TurnID);
1668 if (!((Controller->FirmwareVersion[0] == '5' &&
1669 strcmp(Controller->FirmwareVersion, "5.06") >= 0) ||
1670 (Controller->FirmwareVersion[0] == '4' &&
1671 strcmp(Controller->FirmwareVersion, "4.06") >= 0) ||
1672 (Controller->FirmwareVersion[0] == '3' &&
1673 strcmp(Controller->FirmwareVersion, "3.51") >= 0) ||
1674 (Controller->FirmwareVersion[0] == '2' &&
1675 strcmp(Controller->FirmwareVersion, FIRMWARE_27X) >= 0)))
1677 DAC960_Failure(Controller, "FIRMWARE VERSION VERIFICATION");
1678 DAC960_Error("Firmware Version = '%s'\n", Controller,
1679 Controller->FirmwareVersion);
1680 free_dma_loaf(Controller->PCIDevice, &local_dma);
1681 return false;
1683 /*
1684 Initialize the Controller Channels, Targets, Memory Size, and SAF-TE
1685 Enclosure Management Enabled fields.
1686 */
1687 Controller->Channels = Enquiry2->ActualChannels;
1688 Controller->Targets = Enquiry2->MaxTargets;
1689 Controller->MemorySize = Enquiry2->MemorySize >> 20;
1690 Controller->V1.SAFTE_EnclosureManagementEnabled =
1691 (Enquiry2->FaultManagementType == DAC960_V1_SAFTE);
1692 /*
1693 Initialize the Controller Queue Depth, Driver Queue Depth, Logical Drive
1694 Count, Maximum Blocks per Command, Controller Scatter/Gather Limit, and
1695 Driver Scatter/Gather Limit. The Driver Queue Depth must be at most one
1696 less than the Controller Queue Depth to allow for an automatic drive
1697 rebuild operation.
1698 */
1699 Controller->ControllerQueueDepth = Controller->V1.Enquiry.MaxCommands;
1700 Controller->DriverQueueDepth = Controller->ControllerQueueDepth - 1;
1701 if (Controller->DriverQueueDepth > DAC960_MaxDriverQueueDepth)
1702 Controller->DriverQueueDepth = DAC960_MaxDriverQueueDepth;
1703 Controller->LogicalDriveCount =
1704 Controller->V1.Enquiry.NumberOfLogicalDrives;
1705 Controller->MaxBlocksPerCommand = Enquiry2->MaxBlocksPerCommand;
1706 Controller->ControllerScatterGatherLimit = Enquiry2->MaxScatterGatherEntries;
1707 Controller->DriverScatterGatherLimit =
1708 Controller->ControllerScatterGatherLimit;
1709 if (Controller->DriverScatterGatherLimit > DAC960_V1_ScatterGatherLimit)
1710 Controller->DriverScatterGatherLimit = DAC960_V1_ScatterGatherLimit;
1711 /*
1712 Initialize the Stripe Size, Segment Size, and Geometry Translation.
1713 */
1714 Controller->V1.StripeSize = Config2->BlocksPerStripe * Config2->BlockFactor
1715 >> (10 - DAC960_BlockSizeBits);
1716 Controller->V1.SegmentSize = Config2->BlocksPerCacheLine * Config2->BlockFactor
1717 >> (10 - DAC960_BlockSizeBits);
1718 switch (Config2->DriveGeometry)
1720 case DAC960_V1_Geometry_128_32:
1721 Controller->V1.GeometryTranslationHeads = 128;
1722 Controller->V1.GeometryTranslationSectors = 32;
1723 break;
1724 case DAC960_V1_Geometry_255_63:
1725 Controller->V1.GeometryTranslationHeads = 255;
1726 Controller->V1.GeometryTranslationSectors = 63;
1727 break;
1728 default:
1729 free_dma_loaf(Controller->PCIDevice, &local_dma);
1730 return DAC960_Failure(Controller, "CONFIG2 DRIVE GEOMETRY");
1732 /*
1733 Initialize the Background Initialization Status.
1734 */
1735 if ((Controller->FirmwareVersion[0] == '4' &&
1736 strcmp(Controller->FirmwareVersion, "4.08") >= 0) ||
1737 (Controller->FirmwareVersion[0] == '5' &&
1738 strcmp(Controller->FirmwareVersion, "5.08") >= 0))
1740 Controller->V1.BackgroundInitializationStatusSupported = true;
1741 DAC960_V1_ExecuteType3B(Controller,
1742 DAC960_V1_BackgroundInitializationControl, 0x20,
1743 Controller->
1744 V1.BackgroundInitializationStatusDMA);
1745 memcpy(&Controller->V1.LastBackgroundInitializationStatus,
1746 Controller->V1.BackgroundInitializationStatus,
1747 sizeof(DAC960_V1_BackgroundInitializationStatus_T));
1749 /*
1750 Initialize the Logical Drive Initially Accessible flag.
1751 */
1752 for (LogicalDriveNumber = 0;
1753 LogicalDriveNumber < Controller->LogicalDriveCount;
1754 LogicalDriveNumber++)
1755 if (Controller->V1.LogicalDriveInformation
1756 [LogicalDriveNumber].LogicalDriveState !=
1757 DAC960_V1_LogicalDrive_Offline)
1758 Controller->LogicalDriveInitiallyAccessible[LogicalDriveNumber] = true;
1759 Controller->V1.LastRebuildStatus = DAC960_V1_NoRebuildOrCheckInProgress;
1760 free_dma_loaf(Controller->PCIDevice, &local_dma);
1761 return true;
1765 /*
1766 DAC960_V2_ReadControllerConfiguration reads the Configuration Information
1767 from DAC960 V2 Firmware Controllers and initializes the Controller structure.
1768 */
1770 static boolean DAC960_V2_ReadControllerConfiguration(DAC960_Controller_T
1771 *Controller)
1773 DAC960_V2_ControllerInfo_T *ControllerInfo =
1774 &Controller->V2.ControllerInformation;
1775 unsigned short LogicalDeviceNumber = 0;
1776 int ModelNameLength;
1778 /* Get data into dma-able area, then copy into permanant location */
1779 if (!DAC960_V2_NewControllerInfo(Controller))
1780 return DAC960_Failure(Controller, "GET CONTROLLER INFO");
1781 memcpy(ControllerInfo, Controller->V2.NewControllerInformation,
1782 sizeof(DAC960_V2_ControllerInfo_T));
1785 if (!DAC960_V2_GeneralInfo(Controller))
1786 return DAC960_Failure(Controller, "GET HEALTH STATUS");
1788 /*
1789 Initialize the Controller Model Name and Full Model Name fields.
1790 */
1791 ModelNameLength = sizeof(ControllerInfo->ControllerName);
1792 if (ModelNameLength > sizeof(Controller->ModelName)-1)
1793 ModelNameLength = sizeof(Controller->ModelName)-1;
1794 memcpy(Controller->ModelName, ControllerInfo->ControllerName,
1795 ModelNameLength);
1796 ModelNameLength--;
1797 while (Controller->ModelName[ModelNameLength] == ' ' ||
1798 Controller->ModelName[ModelNameLength] == '\0')
1799 ModelNameLength--;
1800 Controller->ModelName[++ModelNameLength] = '\0';
1801 strcpy(Controller->FullModelName, "Mylex ");
1802 strcat(Controller->FullModelName, Controller->ModelName);
1803 /*
1804 Initialize the Controller Firmware Version field.
1805 */
1806 sprintf(Controller->FirmwareVersion, "%d.%02d-%02d",
1807 ControllerInfo->FirmwareMajorVersion,
1808 ControllerInfo->FirmwareMinorVersion,
1809 ControllerInfo->FirmwareTurnNumber);
1810 if (ControllerInfo->FirmwareMajorVersion == 6 &&
1811 ControllerInfo->FirmwareMinorVersion == 0 &&
1812 ControllerInfo->FirmwareTurnNumber < 1)
1814 DAC960_Info("FIRMWARE VERSION %s DOES NOT PROVIDE THE CONTROLLER\n",
1815 Controller, Controller->FirmwareVersion);
1816 DAC960_Info("STATUS MONITORING FUNCTIONALITY NEEDED BY THIS DRIVER.\n",
1817 Controller);
1818 DAC960_Info("PLEASE UPGRADE TO VERSION 6.00-01 OR ABOVE.\n",
1819 Controller);
1821 /*
1822 Initialize the Controller Channels, Targets, and Memory Size.
1823 */
1824 Controller->Channels = ControllerInfo->NumberOfPhysicalChannelsPresent;
1825 Controller->Targets =
1826 ControllerInfo->MaximumTargetsPerChannel
1827 [ControllerInfo->NumberOfPhysicalChannelsPresent-1];
1828 Controller->MemorySize = ControllerInfo->MemorySizeMB;
1829 /*
1830 Initialize the Controller Queue Depth, Driver Queue Depth, Logical Drive
1831 Count, Maximum Blocks per Command, Controller Scatter/Gather Limit, and
1832 Driver Scatter/Gather Limit. The Driver Queue Depth must be at most one
1833 less than the Controller Queue Depth to allow for an automatic drive
1834 rebuild operation.
1835 */
1836 Controller->ControllerQueueDepth = ControllerInfo->MaximumParallelCommands;
1837 Controller->DriverQueueDepth = Controller->ControllerQueueDepth - 1;
1838 if (Controller->DriverQueueDepth > DAC960_MaxDriverQueueDepth)
1839 Controller->DriverQueueDepth = DAC960_MaxDriverQueueDepth;
1840 Controller->LogicalDriveCount = ControllerInfo->LogicalDevicesPresent;
1841 Controller->MaxBlocksPerCommand =
1842 ControllerInfo->MaximumDataTransferSizeInBlocks;
1843 Controller->ControllerScatterGatherLimit =
1844 ControllerInfo->MaximumScatterGatherEntries;
1845 Controller->DriverScatterGatherLimit =
1846 Controller->ControllerScatterGatherLimit;
1847 if (Controller->DriverScatterGatherLimit > DAC960_V2_ScatterGatherLimit)
1848 Controller->DriverScatterGatherLimit = DAC960_V2_ScatterGatherLimit;
1849 /*
1850 Initialize the Logical Device Information.
1851 */
1852 while (true)
1854 DAC960_V2_LogicalDeviceInfo_T *NewLogicalDeviceInfo =
1855 Controller->V2.NewLogicalDeviceInformation;
1856 DAC960_V2_LogicalDeviceInfo_T *LogicalDeviceInfo;
1857 DAC960_V2_PhysicalDevice_T PhysicalDevice;
1859 if (!DAC960_V2_NewLogicalDeviceInfo(Controller, LogicalDeviceNumber))
1860 break;
1861 LogicalDeviceNumber = NewLogicalDeviceInfo->LogicalDeviceNumber;
1862 if (LogicalDeviceNumber >= DAC960_MaxLogicalDrives) {
1863 DAC960_Error("DAC960: Logical Drive Number %d not supported\n",
1864 Controller, LogicalDeviceNumber);
1865 break;
1867 if (NewLogicalDeviceInfo->DeviceBlockSizeInBytes != DAC960_BlockSize) {
1868 DAC960_Error("DAC960: Logical Drive Block Size %d not supported\n",
1869 Controller, NewLogicalDeviceInfo->DeviceBlockSizeInBytes);
1870 LogicalDeviceNumber++;
1871 continue;
1873 PhysicalDevice.Controller = 0;
1874 PhysicalDevice.Channel = NewLogicalDeviceInfo->Channel;
1875 PhysicalDevice.TargetID = NewLogicalDeviceInfo->TargetID;
1876 PhysicalDevice.LogicalUnit = NewLogicalDeviceInfo->LogicalUnit;
1877 Controller->V2.LogicalDriveToVirtualDevice[LogicalDeviceNumber] =
1878 PhysicalDevice;
1879 if (NewLogicalDeviceInfo->LogicalDeviceState !=
1880 DAC960_V2_LogicalDevice_Offline)
1881 Controller->LogicalDriveInitiallyAccessible[LogicalDeviceNumber] = true;
1882 LogicalDeviceInfo = (DAC960_V2_LogicalDeviceInfo_T *)
1883 kmalloc(sizeof(DAC960_V2_LogicalDeviceInfo_T), GFP_ATOMIC);
1884 if (LogicalDeviceInfo == NULL)
1885 return DAC960_Failure(Controller, "LOGICAL DEVICE ALLOCATION");
1886 Controller->V2.LogicalDeviceInformation[LogicalDeviceNumber] =
1887 LogicalDeviceInfo;
1888 memcpy(LogicalDeviceInfo, NewLogicalDeviceInfo,
1889 sizeof(DAC960_V2_LogicalDeviceInfo_T));
1890 LogicalDeviceNumber++;
1892 return true;
1896 /*
1897 DAC960_ReportControllerConfiguration reports the Configuration Information
1898 for Controller.
1899 */
1901 static boolean DAC960_ReportControllerConfiguration(DAC960_Controller_T
1902 *Controller)
1904 DAC960_Info("Configuring Mylex %s PCI RAID Controller\n",
1905 Controller, Controller->ModelName);
1906 DAC960_Info(" Firmware Version: %s, Channels: %d, Memory Size: %dMB\n",
1907 Controller, Controller->FirmwareVersion,
1908 Controller->Channels, Controller->MemorySize);
1909 DAC960_Info(" PCI Bus: %d, Device: %d, Function: %d, I/O Address: ",
1910 Controller, Controller->Bus,
1911 Controller->Device, Controller->Function);
1912 if (Controller->IO_Address == 0)
1913 DAC960_Info("Unassigned\n", Controller);
1914 else DAC960_Info("0x%X\n", Controller, Controller->IO_Address);
1915 DAC960_Info(" PCI Address: 0x%X mapped at 0x%lX, IRQ Channel: %d\n",
1916 Controller, Controller->PCI_Address,
1917 (unsigned long) Controller->BaseAddress,
1918 Controller->IRQ_Channel);
1919 DAC960_Info(" Controller Queue Depth: %d, "
1920 "Maximum Blocks per Command: %d\n",
1921 Controller, Controller->ControllerQueueDepth,
1922 Controller->MaxBlocksPerCommand);
1923 DAC960_Info(" Driver Queue Depth: %d, "
1924 "Scatter/Gather Limit: %d of %d Segments\n",
1925 Controller, Controller->DriverQueueDepth,
1926 Controller->DriverScatterGatherLimit,
1927 Controller->ControllerScatterGatherLimit);
1928 if (Controller->FirmwareType == DAC960_V1_Controller)
1930 DAC960_Info(" Stripe Size: %dKB, Segment Size: %dKB, "
1931 "BIOS Geometry: %d/%d\n", Controller,
1932 Controller->V1.StripeSize,
1933 Controller->V1.SegmentSize,
1934 Controller->V1.GeometryTranslationHeads,
1935 Controller->V1.GeometryTranslationSectors);
1936 if (Controller->V1.SAFTE_EnclosureManagementEnabled)
1937 DAC960_Info(" SAF-TE Enclosure Management Enabled\n", Controller);
1939 return true;
1943 /*
1944 DAC960_V1_ReadDeviceConfiguration reads the Device Configuration Information
1945 for DAC960 V1 Firmware Controllers by requesting the SCSI Inquiry and SCSI
1946 Inquiry Unit Serial Number information for each device connected to
1947 Controller.
1948 */
1950 static boolean DAC960_V1_ReadDeviceConfiguration(DAC960_Controller_T
1951 *Controller)
1953 struct dma_loaf local_dma;
1955 dma_addr_t DCDBs_dma[DAC960_V1_MaxChannels];
1956 DAC960_V1_DCDB_T *DCDBs_cpu[DAC960_V1_MaxChannels];
1958 dma_addr_t SCSI_Inquiry_dma[DAC960_V1_MaxChannels];
1959 DAC960_SCSI_Inquiry_T *SCSI_Inquiry_cpu[DAC960_V1_MaxChannels];
1961 dma_addr_t SCSI_NewInquiryUnitSerialNumberDMA[DAC960_V1_MaxChannels];
1962 DAC960_SCSI_Inquiry_UnitSerialNumber_T *SCSI_NewInquiryUnitSerialNumberCPU[DAC960_V1_MaxChannels];
1964 struct completion Completions[DAC960_V1_MaxChannels];
1965 unsigned long flags;
1966 int Channel, TargetID;
1968 if (!init_dma_loaf(Controller->PCIDevice, &local_dma,
1969 DAC960_V1_MaxChannels*(sizeof(DAC960_V1_DCDB_T) +
1970 sizeof(DAC960_SCSI_Inquiry_T) +
1971 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T))))
1972 return DAC960_Failure(Controller,
1973 "DMA ALLOCATION FAILED IN ReadDeviceConfiguration");
1975 for (Channel = 0; Channel < Controller->Channels; Channel++) {
1976 DCDBs_cpu[Channel] = slice_dma_loaf(&local_dma,
1977 sizeof(DAC960_V1_DCDB_T), DCDBs_dma + Channel);
1978 SCSI_Inquiry_cpu[Channel] = slice_dma_loaf(&local_dma,
1979 sizeof(DAC960_SCSI_Inquiry_T),
1980 SCSI_Inquiry_dma + Channel);
1981 SCSI_NewInquiryUnitSerialNumberCPU[Channel] = slice_dma_loaf(&local_dma,
1982 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T),
1983 SCSI_NewInquiryUnitSerialNumberDMA + Channel);
1986 for (TargetID = 0; TargetID < Controller->Targets; TargetID++)
1988 /*
1989 * For each channel, submit a probe for a device on that channel.
1990 * The timeout interval for a device that is present is 10 seconds.
1991 * With this approach, the timeout periods can elapse in parallel
1992 * on each channel.
1993 */
1994 for (Channel = 0; Channel < Controller->Channels; Channel++)
1996 dma_addr_t NewInquiryStandardDataDMA = SCSI_Inquiry_dma[Channel];
1997 DAC960_V1_DCDB_T *DCDB = DCDBs_cpu[Channel];
1998 dma_addr_t DCDB_dma = DCDBs_dma[Channel];
1999 DAC960_Command_T *Command = Controller->Commands[Channel];
2000 struct completion *Completion = &Completions[Channel];
2002 init_completion(Completion);
2003 DAC960_V1_ClearCommand(Command);
2004 Command->CommandType = DAC960_ImmediateCommand;
2005 Command->Completion = Completion;
2006 Command->V1.CommandMailbox.Type3.CommandOpcode = DAC960_V1_DCDB;
2007 Command->V1.CommandMailbox.Type3.BusAddress = DCDB_dma;
2008 DCDB->Channel = Channel;
2009 DCDB->TargetID = TargetID;
2010 DCDB->Direction = DAC960_V1_DCDB_DataTransferDeviceToSystem;
2011 DCDB->EarlyStatus = false;
2012 DCDB->Timeout = DAC960_V1_DCDB_Timeout_10_seconds;
2013 DCDB->NoAutomaticRequestSense = false;
2014 DCDB->DisconnectPermitted = true;
2015 DCDB->TransferLength = sizeof(DAC960_SCSI_Inquiry_T);
2016 DCDB->BusAddress = NewInquiryStandardDataDMA;
2017 DCDB->CDBLength = 6;
2018 DCDB->TransferLengthHigh4 = 0;
2019 DCDB->SenseLength = sizeof(DCDB->SenseData);
2020 DCDB->CDB[0] = 0x12; /* INQUIRY */
2021 DCDB->CDB[1] = 0; /* EVPD = 0 */
2022 DCDB->CDB[2] = 0; /* Page Code */
2023 DCDB->CDB[3] = 0; /* Reserved */
2024 DCDB->CDB[4] = sizeof(DAC960_SCSI_Inquiry_T);
2025 DCDB->CDB[5] = 0; /* Control */
2027 spin_lock_irqsave(&Controller->queue_lock, flags);
2028 DAC960_QueueCommand(Command);
2029 spin_unlock_irqrestore(&Controller->queue_lock, flags);
2031 /*
2032 * Wait for the problems submitted in the previous loop
2033 * to complete. On the probes that are successful,
2034 * get the serial number of the device that was found.
2035 */
2036 for (Channel = 0; Channel < Controller->Channels; Channel++)
2038 DAC960_SCSI_Inquiry_T *InquiryStandardData =
2039 &Controller->V1.InquiryStandardData[Channel][TargetID];
2040 DAC960_SCSI_Inquiry_T *NewInquiryStandardData = SCSI_Inquiry_cpu[Channel];
2041 dma_addr_t NewInquiryUnitSerialNumberDMA =
2042 SCSI_NewInquiryUnitSerialNumberDMA[Channel];
2043 DAC960_SCSI_Inquiry_UnitSerialNumber_T *NewInquiryUnitSerialNumber =
2044 SCSI_NewInquiryUnitSerialNumberCPU[Channel];
2045 DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
2046 &Controller->V1.InquiryUnitSerialNumber[Channel][TargetID];
2047 DAC960_Command_T *Command = Controller->Commands[Channel];
2048 DAC960_V1_DCDB_T *DCDB = DCDBs_cpu[Channel];
2049 struct completion *Completion = &Completions[Channel];
2051 wait_for_completion(Completion);
2053 if (Command->V1.CommandStatus != DAC960_V1_NormalCompletion) {
2054 memset(InquiryStandardData, 0, sizeof(DAC960_SCSI_Inquiry_T));
2055 InquiryStandardData->PeripheralDeviceType = 0x1F;
2056 continue;
2057 } else
2058 memcpy(InquiryStandardData, NewInquiryStandardData, sizeof(DAC960_SCSI_Inquiry_T));
2060 /* Preserve Channel and TargetID values from the previous loop */
2061 Command->Completion = Completion;
2062 DCDB->TransferLength = sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T);
2063 DCDB->BusAddress = NewInquiryUnitSerialNumberDMA;
2064 DCDB->SenseLength = sizeof(DCDB->SenseData);
2065 DCDB->CDB[0] = 0x12; /* INQUIRY */
2066 DCDB->CDB[1] = 1; /* EVPD = 1 */
2067 DCDB->CDB[2] = 0x80; /* Page Code */
2068 DCDB->CDB[3] = 0; /* Reserved */
2069 DCDB->CDB[4] = sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T);
2070 DCDB->CDB[5] = 0; /* Control */
2072 spin_lock_irqsave(&Controller->queue_lock, flags);
2073 DAC960_QueueCommand(Command);
2074 spin_unlock_irqrestore(&Controller->queue_lock, flags);
2075 wait_for_completion(Completion);
2077 if (Command->V1.CommandStatus != DAC960_V1_NormalCompletion) {
2078 memset(InquiryUnitSerialNumber, 0,
2079 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
2080 InquiryUnitSerialNumber->PeripheralDeviceType = 0x1F;
2081 } else
2082 memcpy(InquiryUnitSerialNumber, NewInquiryUnitSerialNumber,
2083 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
2086 free_dma_loaf(Controller->PCIDevice, &local_dma);
2087 return true;
2091 /*
2092 DAC960_V2_ReadDeviceConfiguration reads the Device Configuration Information
2093 for DAC960 V2 Firmware Controllers by requesting the Physical Device
2094 Information and SCSI Inquiry Unit Serial Number information for each
2095 device connected to Controller.
2096 */
2098 static boolean DAC960_V2_ReadDeviceConfiguration(DAC960_Controller_T
2099 *Controller)
2101 unsigned char Channel = 0, TargetID = 0, LogicalUnit = 0;
2102 unsigned short PhysicalDeviceIndex = 0;
2104 while (true)
2106 DAC960_V2_PhysicalDeviceInfo_T *NewPhysicalDeviceInfo =
2107 Controller->V2.NewPhysicalDeviceInformation;
2108 DAC960_V2_PhysicalDeviceInfo_T *PhysicalDeviceInfo;
2109 DAC960_SCSI_Inquiry_UnitSerialNumber_T *NewInquiryUnitSerialNumber =
2110 Controller->V2.NewInquiryUnitSerialNumber;
2111 DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber;
2113 if (!DAC960_V2_NewPhysicalDeviceInfo(Controller, Channel, TargetID, LogicalUnit))
2114 break;
2116 PhysicalDeviceInfo = (DAC960_V2_PhysicalDeviceInfo_T *)
2117 kmalloc(sizeof(DAC960_V2_PhysicalDeviceInfo_T), GFP_ATOMIC);
2118 if (PhysicalDeviceInfo == NULL)
2119 return DAC960_Failure(Controller, "PHYSICAL DEVICE ALLOCATION");
2120 Controller->V2.PhysicalDeviceInformation[PhysicalDeviceIndex] =
2121 PhysicalDeviceInfo;
2122 memcpy(PhysicalDeviceInfo, NewPhysicalDeviceInfo,
2123 sizeof(DAC960_V2_PhysicalDeviceInfo_T));
2125 InquiryUnitSerialNumber = (DAC960_SCSI_Inquiry_UnitSerialNumber_T *)
2126 kmalloc(sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T), GFP_ATOMIC);
2127 if (InquiryUnitSerialNumber == NULL) {
2128 kfree(PhysicalDeviceInfo);
2129 return DAC960_Failure(Controller, "SERIAL NUMBER ALLOCATION");
2131 Controller->V2.InquiryUnitSerialNumber[PhysicalDeviceIndex] =
2132 InquiryUnitSerialNumber;
2134 Channel = NewPhysicalDeviceInfo->Channel;
2135 TargetID = NewPhysicalDeviceInfo->TargetID;
2136 LogicalUnit = NewPhysicalDeviceInfo->LogicalUnit;
2138 /*
2139 Some devices do NOT have Unit Serial Numbers.
2140 This command fails for them. But, we still want to
2141 remember those devices are there. Construct a
2142 UnitSerialNumber structure for the failure case.
2143 */
2144 if (!DAC960_V2_NewInquiryUnitSerialNumber(Controller, Channel, TargetID, LogicalUnit)) {
2145 memset(InquiryUnitSerialNumber, 0,
2146 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
2147 InquiryUnitSerialNumber->PeripheralDeviceType = 0x1F;
2148 } else
2149 memcpy(InquiryUnitSerialNumber, NewInquiryUnitSerialNumber,
2150 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
2152 PhysicalDeviceIndex++;
2153 LogicalUnit++;
2155 return true;
2159 /*
2160 DAC960_SanitizeInquiryData sanitizes the Vendor, Model, Revision, and
2161 Product Serial Number fields of the Inquiry Standard Data and Inquiry
2162 Unit Serial Number structures.
2163 */
2165 static void DAC960_SanitizeInquiryData(DAC960_SCSI_Inquiry_T
2166 *InquiryStandardData,
2167 DAC960_SCSI_Inquiry_UnitSerialNumber_T
2168 *InquiryUnitSerialNumber,
2169 unsigned char *Vendor,
2170 unsigned char *Model,
2171 unsigned char *Revision,
2172 unsigned char *SerialNumber)
2174 int SerialNumberLength, i;
2175 if (InquiryStandardData->PeripheralDeviceType == 0x1F) return;
2176 for (i = 0; i < sizeof(InquiryStandardData->VendorIdentification); i++)
2178 unsigned char VendorCharacter =
2179 InquiryStandardData->VendorIdentification[i];
2180 Vendor[i] = (VendorCharacter >= ' ' && VendorCharacter <= '~'
2181 ? VendorCharacter : ' ');
2183 Vendor[sizeof(InquiryStandardData->VendorIdentification)] = '\0';
2184 for (i = 0; i < sizeof(InquiryStandardData->ProductIdentification); i++)
2186 unsigned char ModelCharacter =
2187 InquiryStandardData->ProductIdentification[i];
2188 Model[i] = (ModelCharacter >= ' ' && ModelCharacter <= '~'
2189 ? ModelCharacter : ' ');
2191 Model[sizeof(InquiryStandardData->ProductIdentification)] = '\0';
2192 for (i = 0; i < sizeof(InquiryStandardData->ProductRevisionLevel); i++)
2194 unsigned char RevisionCharacter =
2195 InquiryStandardData->ProductRevisionLevel[i];
2196 Revision[i] = (RevisionCharacter >= ' ' && RevisionCharacter <= '~'
2197 ? RevisionCharacter : ' ');
2199 Revision[sizeof(InquiryStandardData->ProductRevisionLevel)] = '\0';
2200 if (InquiryUnitSerialNumber->PeripheralDeviceType == 0x1F) return;
2201 SerialNumberLength = InquiryUnitSerialNumber->PageLength;
2202 if (SerialNumberLength >
2203 sizeof(InquiryUnitSerialNumber->ProductSerialNumber))
2204 SerialNumberLength = sizeof(InquiryUnitSerialNumber->ProductSerialNumber);
2205 for (i = 0; i < SerialNumberLength; i++)
2207 unsigned char SerialNumberCharacter =
2208 InquiryUnitSerialNumber->ProductSerialNumber[i];
2209 SerialNumber[i] =
2210 (SerialNumberCharacter >= ' ' && SerialNumberCharacter <= '~'
2211 ? SerialNumberCharacter : ' ');
2213 SerialNumber[SerialNumberLength] = '\0';
2217 /*
2218 DAC960_V1_ReportDeviceConfiguration reports the Device Configuration
2219 Information for DAC960 V1 Firmware Controllers.
2220 */
2222 static boolean DAC960_V1_ReportDeviceConfiguration(DAC960_Controller_T
2223 *Controller)
2225 int LogicalDriveNumber, Channel, TargetID;
2226 DAC960_Info(" Physical Devices:\n", Controller);
2227 for (Channel = 0; Channel < Controller->Channels; Channel++)
2228 for (TargetID = 0; TargetID < Controller->Targets; TargetID++)
2230 DAC960_SCSI_Inquiry_T *InquiryStandardData =
2231 &Controller->V1.InquiryStandardData[Channel][TargetID];
2232 DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
2233 &Controller->V1.InquiryUnitSerialNumber[Channel][TargetID];
2234 DAC960_V1_DeviceState_T *DeviceState =
2235 &Controller->V1.DeviceState[Channel][TargetID];
2236 DAC960_V1_ErrorTableEntry_T *ErrorEntry =
2237 &Controller->V1.ErrorTable.ErrorTableEntries[Channel][TargetID];
2238 char Vendor[1+sizeof(InquiryStandardData->VendorIdentification)];
2239 char Model[1+sizeof(InquiryStandardData->ProductIdentification)];
2240 char Revision[1+sizeof(InquiryStandardData->ProductRevisionLevel)];
2241 char SerialNumber[1+sizeof(InquiryUnitSerialNumber
2242 ->ProductSerialNumber)];
2243 if (InquiryStandardData->PeripheralDeviceType == 0x1F) continue;
2244 DAC960_SanitizeInquiryData(InquiryStandardData, InquiryUnitSerialNumber,
2245 Vendor, Model, Revision, SerialNumber);
2246 DAC960_Info(" %d:%d%s Vendor: %s Model: %s Revision: %s\n",
2247 Controller, Channel, TargetID, (TargetID < 10 ? " " : ""),
2248 Vendor, Model, Revision);
2249 if (InquiryUnitSerialNumber->PeripheralDeviceType != 0x1F)
2250 DAC960_Info(" Serial Number: %s\n", Controller, SerialNumber);
2251 if (DeviceState->Present &&
2252 DeviceState->DeviceType == DAC960_V1_DiskType)
2254 if (Controller->V1.DeviceResetCount[Channel][TargetID] > 0)
2255 DAC960_Info(" Disk Status: %s, %u blocks, %d resets\n",
2256 Controller,
2257 (DeviceState->DeviceState == DAC960_V1_Device_Dead
2258 ? "Dead"
2259 : DeviceState->DeviceState
2260 == DAC960_V1_Device_WriteOnly
2261 ? "Write-Only"
2262 : DeviceState->DeviceState
2263 == DAC960_V1_Device_Online
2264 ? "Online" : "Standby"),
2265 DeviceState->DiskSize,
2266 Controller->V1.DeviceResetCount[Channel][TargetID]);
2267 else
2268 DAC960_Info(" Disk Status: %s, %u blocks\n", Controller,
2269 (DeviceState->DeviceState == DAC960_V1_Device_Dead
2270 ? "Dead"
2271 : DeviceState->DeviceState
2272 == DAC960_V1_Device_WriteOnly
2273 ? "Write-Only"
2274 : DeviceState->DeviceState
2275 == DAC960_V1_Device_Online
2276 ? "Online" : "Standby"),
2277 DeviceState->DiskSize);
2279 if (ErrorEntry->ParityErrorCount > 0 ||
2280 ErrorEntry->SoftErrorCount > 0 ||
2281 ErrorEntry->HardErrorCount > 0 ||
2282 ErrorEntry->MiscErrorCount > 0)
2283 DAC960_Info(" Errors - Parity: %d, Soft: %d, "
2284 "Hard: %d, Misc: %d\n", Controller,
2285 ErrorEntry->ParityErrorCount,
2286 ErrorEntry->SoftErrorCount,
2287 ErrorEntry->HardErrorCount,
2288 ErrorEntry->MiscErrorCount);
2290 DAC960_Info(" Logical Drives:\n", Controller);
2291 for (LogicalDriveNumber = 0;
2292 LogicalDriveNumber < Controller->LogicalDriveCount;
2293 LogicalDriveNumber++)
2295 DAC960_V1_LogicalDriveInformation_T *LogicalDriveInformation =
2296 &Controller->V1.LogicalDriveInformation[LogicalDriveNumber];
2297 DAC960_Info(" /dev/rd/c%dd%d: RAID-%d, %s, %u blocks, %s\n",
2298 Controller, Controller->ControllerNumber, LogicalDriveNumber,
2299 LogicalDriveInformation->RAIDLevel,
2300 (LogicalDriveInformation->LogicalDriveState
2301 == DAC960_V1_LogicalDrive_Online
2302 ? "Online"
2303 : LogicalDriveInformation->LogicalDriveState
2304 == DAC960_V1_LogicalDrive_Critical
2305 ? "Critical" : "Offline"),
2306 LogicalDriveInformation->LogicalDriveSize,
2307 (LogicalDriveInformation->WriteBack
2308 ? "Write Back" : "Write Thru"));
2310 return true;
2314 /*
2315 DAC960_V2_ReportDeviceConfiguration reports the Device Configuration
2316 Information for DAC960 V2 Firmware Controllers.
2317 */
2319 static boolean DAC960_V2_ReportDeviceConfiguration(DAC960_Controller_T
2320 *Controller)
2322 int PhysicalDeviceIndex, LogicalDriveNumber;
2323 DAC960_Info(" Physical Devices:\n", Controller);
2324 for (PhysicalDeviceIndex = 0;
2325 PhysicalDeviceIndex < DAC960_V2_MaxPhysicalDevices;
2326 PhysicalDeviceIndex++)
2328 DAC960_V2_PhysicalDeviceInfo_T *PhysicalDeviceInfo =
2329 Controller->V2.PhysicalDeviceInformation[PhysicalDeviceIndex];
2330 DAC960_SCSI_Inquiry_T *InquiryStandardData =
2331 (DAC960_SCSI_Inquiry_T *) &PhysicalDeviceInfo->SCSI_InquiryData;
2332 DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
2333 Controller->V2.InquiryUnitSerialNumber[PhysicalDeviceIndex];
2334 char Vendor[1+sizeof(InquiryStandardData->VendorIdentification)];
2335 char Model[1+sizeof(InquiryStandardData->ProductIdentification)];
2336 char Revision[1+sizeof(InquiryStandardData->ProductRevisionLevel)];
2337 char SerialNumber[1+sizeof(InquiryUnitSerialNumber->ProductSerialNumber)];
2338 if (PhysicalDeviceInfo == NULL) break;
2339 DAC960_SanitizeInquiryData(InquiryStandardData, InquiryUnitSerialNumber,
2340 Vendor, Model, Revision, SerialNumber);
2341 DAC960_Info(" %d:%d%s Vendor: %s Model: %s Revision: %s\n",
2342 Controller,
2343 PhysicalDeviceInfo->Channel,
2344 PhysicalDeviceInfo->TargetID,
2345 (PhysicalDeviceInfo->TargetID < 10 ? " " : ""),
2346 Vendor, Model, Revision);
2347 if (PhysicalDeviceInfo->NegotiatedSynchronousMegaTransfers == 0)
2348 DAC960_Info(" %sAsynchronous\n", Controller,
2349 (PhysicalDeviceInfo->NegotiatedDataWidthBits == 16
2350 ? "Wide " :""));
2351 else
2352 DAC960_Info(" %sSynchronous at %d MB/sec\n", Controller,
2353 (PhysicalDeviceInfo->NegotiatedDataWidthBits == 16
2354 ? "Wide " :""),
2355 (PhysicalDeviceInfo->NegotiatedSynchronousMegaTransfers
2356 * PhysicalDeviceInfo->NegotiatedDataWidthBits/8));
2357 if (InquiryUnitSerialNumber->PeripheralDeviceType != 0x1F)
2358 DAC960_Info(" Serial Number: %s\n", Controller, SerialNumber);
2359 if (PhysicalDeviceInfo->PhysicalDeviceState ==
2360 DAC960_V2_Device_Unconfigured)
2361 continue;
2362 DAC960_Info(" Disk Status: %s, %u blocks\n", Controller,
2363 (PhysicalDeviceInfo->PhysicalDeviceState
2364 == DAC960_V2_Device_Online
2365 ? "Online"
2366 : PhysicalDeviceInfo->PhysicalDeviceState
2367 == DAC960_V2_Device_Rebuild
2368 ? "Rebuild"
2369 : PhysicalDeviceInfo->PhysicalDeviceState
2370 == DAC960_V2_Device_Missing
2371 ? "Missing"
2372 : PhysicalDeviceInfo->PhysicalDeviceState
2373 == DAC960_V2_Device_Critical
2374 ? "Critical"
2375 : PhysicalDeviceInfo->PhysicalDeviceState
2376 == DAC960_V2_Device_Dead
2377 ? "Dead"
2378 : PhysicalDeviceInfo->PhysicalDeviceState
2379 == DAC960_V2_Device_SuspectedDead
2380 ? "Suspected-Dead"
2381 : PhysicalDeviceInfo->PhysicalDeviceState
2382 == DAC960_V2_Device_CommandedOffline
2383 ? "Commanded-Offline"
2384 : PhysicalDeviceInfo->PhysicalDeviceState
2385 == DAC960_V2_Device_Standby
2386 ? "Standby" : "Unknown"),
2387 PhysicalDeviceInfo->ConfigurableDeviceSize);
2388 if (PhysicalDeviceInfo->ParityErrors == 0 &&
2389 PhysicalDeviceInfo->SoftErrors == 0 &&
2390 PhysicalDeviceInfo->HardErrors == 0 &&
2391 PhysicalDeviceInfo->MiscellaneousErrors == 0 &&
2392 PhysicalDeviceInfo->CommandTimeouts == 0 &&
2393 PhysicalDeviceInfo->Retries == 0 &&
2394 PhysicalDeviceInfo->Aborts == 0 &&
2395 PhysicalDeviceInfo->PredictedFailuresDetected == 0)
2396 continue;
2397 DAC960_Info(" Errors - Parity: %d, Soft: %d, "
2398 "Hard: %d, Misc: %d\n", Controller,
2399 PhysicalDeviceInfo->ParityErrors,
2400 PhysicalDeviceInfo->SoftErrors,
2401 PhysicalDeviceInfo->HardErrors,
2402 PhysicalDeviceInfo->MiscellaneousErrors);
2403 DAC960_Info(" Timeouts: %d, Retries: %d, "
2404 "Aborts: %d, Predicted: %d\n", Controller,
2405 PhysicalDeviceInfo->CommandTimeouts,
2406 PhysicalDeviceInfo->Retries,
2407 PhysicalDeviceInfo->Aborts,
2408 PhysicalDeviceInfo->PredictedFailuresDetected);
2410 DAC960_Info(" Logical Drives:\n", Controller);
2411 for (LogicalDriveNumber = 0;
2412 LogicalDriveNumber < DAC960_MaxLogicalDrives;
2413 LogicalDriveNumber++)
2415 DAC960_V2_LogicalDeviceInfo_T *LogicalDeviceInfo =
2416 Controller->V2.LogicalDeviceInformation[LogicalDriveNumber];
2417 unsigned char *ReadCacheStatus[] = { "Read Cache Disabled",
2418 "Read Cache Enabled",
2419 "Read Ahead Enabled",
2420 "Intelligent Read Ahead Enabled",
2421 "-", "-", "-", "-" };
2422 unsigned char *WriteCacheStatus[] = { "Write Cache Disabled",
2423 "Logical Device Read Only",
2424 "Write Cache Enabled",
2425 "Intelligent Write Cache Enabled",
2426 "-", "-", "-", "-" };
2427 unsigned char *GeometryTranslation;
2428 if (LogicalDeviceInfo == NULL) continue;
2429 switch (LogicalDeviceInfo->DriveGeometry)
2431 case DAC960_V2_Geometry_128_32:
2432 GeometryTranslation = "128/32";
2433 break;
2434 case DAC960_V2_Geometry_255_63:
2435 GeometryTranslation = "255/63";
2436 break;
2437 default:
2438 GeometryTranslation = "Invalid";
2439 DAC960_Error("Illegal Logical Device Geometry %d\n",
2440 Controller, LogicalDeviceInfo->DriveGeometry);
2441 break;
2443 DAC960_Info(" /dev/rd/c%dd%d: RAID-%d, %s, %u blocks\n",
2444 Controller, Controller->ControllerNumber, LogicalDriveNumber,
2445 LogicalDeviceInfo->RAIDLevel,
2446 (LogicalDeviceInfo->LogicalDeviceState
2447 == DAC960_V2_LogicalDevice_Online
2448 ? "Online"
2449 : LogicalDeviceInfo->LogicalDeviceState
2450 == DAC960_V2_LogicalDevice_Critical
2451 ? "Critical" : "Offline"),
2452 LogicalDeviceInfo->ConfigurableDeviceSize);
2453 DAC960_Info(" Logical Device %s, BIOS Geometry: %s\n",
2454 Controller,
2455 (LogicalDeviceInfo->LogicalDeviceControl
2456 .LogicalDeviceInitialized
2457 ? "Initialized" : "Uninitialized"),
2458 GeometryTranslation);
2459 if (LogicalDeviceInfo->StripeSize == 0)
2461 if (LogicalDeviceInfo->CacheLineSize == 0)
2462 DAC960_Info(" Stripe Size: N/A, "
2463 "Segment Size: N/A\n", Controller);
2464 else
2465 DAC960_Info(" Stripe Size: N/A, "
2466 "Segment Size: %dKB\n", Controller,
2467 1 << (LogicalDeviceInfo->CacheLineSize - 2));
2469 else
2471 if (LogicalDeviceInfo->CacheLineSize == 0)
2472 DAC960_Info(" Stripe Size: %dKB, "
2473 "Segment Size: N/A\n", Controller,
2474 1 << (LogicalDeviceInfo->StripeSize - 2));
2475 else
2476 DAC960_Info(" Stripe Size: %dKB, "
2477 "Segment Size: %dKB\n", Controller,
2478 1 << (LogicalDeviceInfo->StripeSize - 2),
2479 1 << (LogicalDeviceInfo->CacheLineSize - 2));
2481 DAC960_Info(" %s, %s\n", Controller,
2482 ReadCacheStatus[
2483 LogicalDeviceInfo->LogicalDeviceControl.ReadCache],
2484 WriteCacheStatus[
2485 LogicalDeviceInfo->LogicalDeviceControl.WriteCache]);
2486 if (LogicalDeviceInfo->SoftErrors > 0 ||
2487 LogicalDeviceInfo->CommandsFailed > 0 ||
2488 LogicalDeviceInfo->DeferredWriteErrors)
2489 DAC960_Info(" Errors - Soft: %d, Failed: %d, "
2490 "Deferred Write: %d\n", Controller,
2491 LogicalDeviceInfo->SoftErrors,
2492 LogicalDeviceInfo->CommandsFailed,
2493 LogicalDeviceInfo->DeferredWriteErrors);
2496 return true;
2499 /*
2500 DAC960_RegisterBlockDevice registers the Block Device structures
2501 associated with Controller.
2502 */
2504 static boolean DAC960_RegisterBlockDevice(DAC960_Controller_T *Controller)
2506 int MajorNumber = DAC960_MAJOR + Controller->ControllerNumber;
2507 int n;
2509 /*
2510 Register the Block Device Major Number for this DAC960 Controller.
2511 */
2512 if (register_blkdev(MajorNumber, "dac960") < 0)
2513 return false;
2515 for (n = 0; n < DAC960_MaxLogicalDrives; n++) {
2516 struct gendisk *disk = Controller->disks[n];
2517 struct request_queue *RequestQueue;
2519 /* for now, let all request queues share controller's lock */
2520 RequestQueue = blk_init_queue(DAC960_RequestFunction,&Controller->queue_lock);
2521 if (!RequestQueue) {
2522 printk("DAC960: failure to allocate request queue\n");
2523 continue;
2525 Controller->RequestQueue[n] = RequestQueue;
2526 blk_queue_bounce_limit(RequestQueue, Controller->BounceBufferLimit);
2527 RequestQueue->queuedata = Controller;
2528 blk_queue_max_hw_segments(RequestQueue, Controller->DriverScatterGatherLimit);
2529 blk_queue_max_phys_segments(RequestQueue, Controller->DriverScatterGatherLimit);
2530 blk_queue_max_sectors(RequestQueue, Controller->MaxBlocksPerCommand);
2531 disk->queue = RequestQueue;
2532 sprintf(disk->disk_name, "rd/c%dd%d", Controller->ControllerNumber, n);
2533 disk->major = MajorNumber;
2534 disk->first_minor = n << DAC960_MaxPartitionsBits;
2535 disk->fops = &DAC960_BlockDeviceOperations;
2537 /*
2538 Indicate the Block Device Registration completed successfully,
2539 */
2540 return true;
2544 /*
2545 DAC960_UnregisterBlockDevice unregisters the Block Device structures
2546 associated with Controller.
2547 */
2549 static void DAC960_UnregisterBlockDevice(DAC960_Controller_T *Controller)
2551 int MajorNumber = DAC960_MAJOR + Controller->ControllerNumber;
2552 int disk;
2554 /* does order matter when deleting gendisk and cleanup in request queue? */
2555 for (disk = 0; disk < DAC960_MaxLogicalDrives; disk++) {
2556 del_gendisk(Controller->disks[disk]);
2557 blk_cleanup_queue(Controller->RequestQueue[disk]);
2558 Controller->RequestQueue[disk] = NULL;
2561 /*
2562 Unregister the Block Device Major Number for this DAC960 Controller.
2563 */
2564 unregister_blkdev(MajorNumber, "dac960");
2567 /*
2568 DAC960_ComputeGenericDiskInfo computes the values for the Generic Disk
2569 Information Partition Sector Counts and Block Sizes.
2570 */
2572 static void DAC960_ComputeGenericDiskInfo(DAC960_Controller_T *Controller)
2574 int disk;
2575 for (disk = 0; disk < DAC960_MaxLogicalDrives; disk++)
2576 set_capacity(Controller->disks[disk], disk_size(Controller, disk));
2579 /*
2580 DAC960_ReportErrorStatus reports Controller BIOS Messages passed through
2581 the Error Status Register when the driver performs the BIOS handshaking.
2582 It returns true for fatal errors and false otherwise.
2583 */
2585 static boolean DAC960_ReportErrorStatus(DAC960_Controller_T *Controller,
2586 unsigned char ErrorStatus,
2587 unsigned char Parameter0,
2588 unsigned char Parameter1)
2590 switch (ErrorStatus)
2592 case 0x00:
2593 DAC960_Notice("Physical Device %d:%d Not Responding\n",
2594 Controller, Parameter1, Parameter0);
2595 break;
2596 case 0x08:
2597 if (Controller->DriveSpinUpMessageDisplayed) break;
2598 DAC960_Notice("Spinning Up Drives\n", Controller);
2599 Controller->DriveSpinUpMessageDisplayed = true;
2600 break;
2601 case 0x30:
2602 DAC960_Notice("Configuration Checksum Error\n", Controller);
2603 break;
2604 case 0x60:
2605 DAC960_Notice("Mirror Race Recovery Failed\n", Controller);
2606 break;
2607 case 0x70:
2608 DAC960_Notice("Mirror Race Recovery In Progress\n", Controller);
2609 break;
2610 case 0x90:
2611 DAC960_Notice("Physical Device %d:%d COD Mismatch\n",
2612 Controller, Parameter1, Parameter0);
2613 break;
2614 case 0xA0:
2615 DAC960_Notice("Logical Drive Installation Aborted\n", Controller);
2616 break;
2617 case 0xB0:
2618 DAC960_Notice("Mirror Race On A Critical Logical Drive\n", Controller);
2619 break;
2620 case 0xD0:
2621 DAC960_Notice("New Controller Configuration Found\n", Controller);
2622 break;
2623 case 0xF0:
2624 DAC960_Error("Fatal Memory Parity Error for Controller at\n", Controller);
2625 return true;
2626 default:
2627 DAC960_Error("Unknown Initialization Error %02X for Controller at\n",
2628 Controller, ErrorStatus);
2629 return true;
2631 return false;
2635 /*
2636 * DAC960_DetectCleanup releases the resources that were allocated
2637 * during DAC960_DetectController(). DAC960_DetectController can
2638 * has several internal failure points, so not ALL resources may
2639 * have been allocated. It's important to free only
2640 * resources that HAVE been allocated. The code below always
2641 * tests that the resource has been allocated before attempting to
2642 * free it.
2643 */
2644 static void DAC960_DetectCleanup(DAC960_Controller_T *Controller)
2646 int i;
2648 /* Free the memory mailbox, status, and related structures */
2649 free_dma_loaf(Controller->PCIDevice, &Controller->DmaPages);
2650 if (Controller->MemoryMappedAddress) {
2651 switch(Controller->HardwareType)
2653 case DAC960_GEM_Controller:
2654 DAC960_GEM_DisableInterrupts(Controller->BaseAddress);
2655 break;
2656 case DAC960_BA_Controller:
2657 DAC960_BA_DisableInterrupts(Controller->BaseAddress);
2658 break;
2659 case DAC960_LP_Controller:
2660 DAC960_LP_DisableInterrupts(Controller->BaseAddress);
2661 break;
2662 case DAC960_LA_Controller:
2663 DAC960_LA_DisableInterrupts(Controller->BaseAddress);
2664 break;
2665 case DAC960_PG_Controller:
2666 DAC960_PG_DisableInterrupts(Controller->BaseAddress);
2667 break;
2668 case DAC960_PD_Controller:
2669 DAC960_PD_DisableInterrupts(Controller->BaseAddress);
2670 break;
2671 case DAC960_P_Controller:
2672 DAC960_PD_DisableInterrupts(Controller->BaseAddress);
2673 break;
2675 iounmap(Controller->MemoryMappedAddress);
2677 if (Controller->IRQ_Channel)
2678 free_irq(Controller->IRQ_Channel, Controller);
2679 if (Controller->IO_Address)
2680 release_region(Controller->IO_Address, 0x80);
2681 pci_disable_device(Controller->PCIDevice);
2682 for (i = 0; (i < DAC960_MaxLogicalDrives) && Controller->disks[i]; i++)
2683 put_disk(Controller->disks[i]);
2684 DAC960_Controllers[Controller->ControllerNumber] = NULL;
2685 kfree(Controller);
2689 /*
2690 DAC960_DetectController detects Mylex DAC960/AcceleRAID/eXtremeRAID
2691 PCI RAID Controllers by interrogating the PCI Configuration Space for
2692 Controller Type.
2693 */
2695 static DAC960_Controller_T *
2696 DAC960_DetectController(struct pci_dev *PCI_Device,
2697 const struct pci_device_id *entry)
2699 struct DAC960_privdata *privdata =
2700 (struct DAC960_privdata *)entry->driver_data;
2701 irqreturn_t (*InterruptHandler)(int, void *, struct pt_regs *) =
2702 privdata->InterruptHandler;
2703 unsigned int MemoryWindowSize = privdata->MemoryWindowSize;
2704 DAC960_Controller_T *Controller = NULL;
2705 unsigned char DeviceFunction = PCI_Device->devfn;
2706 unsigned char ErrorStatus, Parameter0, Parameter1;
2707 unsigned int IRQ_Channel;
2708 void __iomem *BaseAddress;
2709 int i;
2711 Controller = kzalloc(sizeof(DAC960_Controller_T), GFP_ATOMIC);
2712 if (Controller == NULL) {
2713 DAC960_Error("Unable to allocate Controller structure for "
2714 "Controller at\n", NULL);
2715 return NULL;
2717 Controller->ControllerNumber = DAC960_ControllerCount;
2718 DAC960_Controllers[DAC960_ControllerCount++] = Controller;
2719 Controller->Bus = PCI_Device->bus->number;
2720 Controller->FirmwareType = privdata->FirmwareType;
2721 Controller->HardwareType = privdata->HardwareType;
2722 Controller->Device = DeviceFunction >> 3;
2723 Controller->Function = DeviceFunction & 0x7;
2724 Controller->PCIDevice = PCI_Device;
2725 strcpy(Controller->FullModelName, "DAC960");
2727 if (pci_enable_device(PCI_Device))
2728 goto Failure;
2730 switch (Controller->HardwareType)
2732 case DAC960_GEM_Controller:
2733 Controller->PCI_Address = pci_resource_start(PCI_Device, 0);
2734 break;
2735 case DAC960_BA_Controller:
2736 Controller->PCI_Address = pci_resource_start(PCI_Device, 0);
2737 break;
2738 case DAC960_LP_Controller:
2739 Controller->PCI_Address = pci_resource_start(PCI_Device, 0);
2740 break;
2741 case DAC960_LA_Controller:
2742 Controller->PCI_Address = pci_resource_start(PCI_Device, 0);
2743 break;
2744 case DAC960_PG_Controller:
2745 Controller->PCI_Address = pci_resource_start(PCI_Device, 0);
2746 break;
2747 case DAC960_PD_Controller:
2748 Controller->IO_Address = pci_resource_start(PCI_Device, 0);
2749 Controller->PCI_Address = pci_resource_start(PCI_Device, 1);
2750 break;
2751 case DAC960_P_Controller:
2752 Controller->IO_Address = pci_resource_start(PCI_Device, 0);
2753 Controller->PCI_Address = pci_resource_start(PCI_Device, 1);
2754 break;
2757 pci_set_drvdata(PCI_Device, (void *)((long)Controller->ControllerNumber));
2758 for (i = 0; i < DAC960_MaxLogicalDrives; i++) {
2759 Controller->disks[i] = alloc_disk(1<<DAC960_MaxPartitionsBits);
2760 if (!Controller->disks[i])
2761 goto Failure;
2762 Controller->disks[i]->private_data = (void *)((long)i);
2764 init_waitqueue_head(&Controller->CommandWaitQueue);
2765 init_waitqueue_head(&Controller->HealthStatusWaitQueue);
2766 spin_lock_init(&Controller->queue_lock);
2767 DAC960_AnnounceDriver(Controller);
2768 /*
2769 Map the Controller Register Window.
2770 */
2771 if (MemoryWindowSize < PAGE_SIZE)
2772 MemoryWindowSize = PAGE_SIZE;
2773 Controller->MemoryMappedAddress =
2774 ioremap_nocache(Controller->PCI_Address & PAGE_MASK, MemoryWindowSize);
2775 Controller->BaseAddress =
2776 Controller->MemoryMappedAddress + (Controller->PCI_Address & ~PAGE_MASK);
2777 if (Controller->MemoryMappedAddress == NULL)
2779 DAC960_Error("Unable to map Controller Register Window for "
2780 "Controller at\n", Controller);
2781 goto Failure;
2783 BaseAddress = Controller->BaseAddress;
2784 switch (Controller->HardwareType)
2786 case DAC960_GEM_Controller:
2787 DAC960_GEM_DisableInterrupts(BaseAddress);
2788 DAC960_GEM_AcknowledgeHardwareMailboxStatus(BaseAddress);
2789 udelay(1000);
2790 while (DAC960_GEM_InitializationInProgressP(BaseAddress))
2792 if (DAC960_GEM_ReadErrorStatus(BaseAddress, &ErrorStatus,
2793 &Parameter0, &Parameter1) &&
2794 DAC960_ReportErrorStatus(Controller, ErrorStatus,
2795 Parameter0, Parameter1))
2796 goto Failure;
2797 udelay(10);
2799 if (!DAC960_V2_EnableMemoryMailboxInterface(Controller))
2801 DAC960_Error("Unable to Enable Memory Mailbox Interface "
2802 "for Controller at\n", Controller);
2803 goto Failure;
2805 DAC960_GEM_EnableInterrupts(BaseAddress);
2806 Controller->QueueCommand = DAC960_GEM_QueueCommand;
2807 Controller->ReadControllerConfiguration =
2808 DAC960_V2_ReadControllerConfiguration;
2809 Controller->ReadDeviceConfiguration =
2810 DAC960_V2_ReadDeviceConfiguration;
2811 Controller->ReportDeviceConfiguration =
2812 DAC960_V2_ReportDeviceConfiguration;
2813 Controller->QueueReadWriteCommand =
2814 DAC960_V2_QueueReadWriteCommand;
2815 break;
2816 case DAC960_BA_Controller:
2817 DAC960_BA_DisableInterrupts(BaseAddress);
2818 DAC960_BA_AcknowledgeHardwareMailboxStatus(BaseAddress);
2819 udelay(1000);
2820 while (DAC960_BA_InitializationInProgressP(BaseAddress))
2822 if (DAC960_BA_ReadErrorStatus(BaseAddress, &ErrorStatus,
2823 &Parameter0, &Parameter1) &&
2824 DAC960_ReportErrorStatus(Controller, ErrorStatus,
2825 Parameter0, Parameter1))
2826 goto Failure;
2827 udelay(10);
2829 if (!DAC960_V2_EnableMemoryMailboxInterface(Controller))
2831 DAC960_Error("Unable to Enable Memory Mailbox Interface "
2832 "for Controller at\n", Controller);
2833 goto Failure;
2835 DAC960_BA_EnableInterrupts(BaseAddress);
2836 Controller->QueueCommand = DAC960_BA_QueueCommand;
2837 Controller->ReadControllerConfiguration =
2838 DAC960_V2_ReadControllerConfiguration;
2839 Controller->ReadDeviceConfiguration =
2840 DAC960_V2_ReadDeviceConfiguration;
2841 Controller->ReportDeviceConfiguration =
2842 DAC960_V2_ReportDeviceConfiguration;
2843 Controller->QueueReadWriteCommand =
2844 DAC960_V2_QueueReadWriteCommand;
2845 break;
2846 case DAC960_LP_Controller:
2847 DAC960_LP_DisableInterrupts(BaseAddress);
2848 DAC960_LP_AcknowledgeHardwareMailboxStatus(BaseAddress);
2849 udelay(1000);
2850 while (DAC960_LP_InitializationInProgressP(BaseAddress))
2852 if (DAC960_LP_ReadErrorStatus(BaseAddress, &ErrorStatus,
2853 &Parameter0, &Parameter1) &&
2854 DAC960_ReportErrorStatus(Controller, ErrorStatus,
2855 Parameter0, Parameter1))
2856 goto Failure;
2857 udelay(10);
2859 if (!DAC960_V2_EnableMemoryMailboxInterface(Controller))
2861 DAC960_Error("Unable to Enable Memory Mailbox Interface "
2862 "for Controller at\n", Controller);
2863 goto Failure;
2865 DAC960_LP_EnableInterrupts(BaseAddress);
2866 Controller->QueueCommand = DAC960_LP_QueueCommand;
2867 Controller->ReadControllerConfiguration =
2868 DAC960_V2_ReadControllerConfiguration;
2869 Controller->ReadDeviceConfiguration =
2870 DAC960_V2_ReadDeviceConfiguration;
2871 Controller->ReportDeviceConfiguration =
2872 DAC960_V2_ReportDeviceConfiguration;
2873 Controller->QueueReadWriteCommand =
2874 DAC960_V2_QueueReadWriteCommand;
2875 break;
2876 case DAC960_LA_Controller:
2877 DAC960_LA_DisableInterrupts(BaseAddress);
2878 DAC960_LA_AcknowledgeHardwareMailboxStatus(BaseAddress);
2879 udelay(1000);
2880 while (DAC960_LA_InitializationInProgressP(BaseAddress))
2882 if (DAC960_LA_ReadErrorStatus(BaseAddress, &ErrorStatus,
2883 &Parameter0, &Parameter1) &&
2884 DAC960_ReportErrorStatus(Controller, ErrorStatus,
2885 Parameter0, Parameter1))
2886 goto Failure;
2887 udelay(10);
2889 if (!DAC960_V1_EnableMemoryMailboxInterface(Controller))
2891 DAC960_Error("Unable to Enable Memory Mailbox Interface "
2892 "for Controller at\n", Controller);
2893 goto Failure;
2895 DAC960_LA_EnableInterrupts(BaseAddress);
2896 if (Controller->V1.DualModeMemoryMailboxInterface)
2897 Controller->QueueCommand = DAC960_LA_QueueCommandDualMode;
2898 else Controller->QueueCommand = DAC960_LA_QueueCommandSingleMode;
2899 Controller->ReadControllerConfiguration =
2900 DAC960_V1_ReadControllerConfiguration;
2901 Controller->ReadDeviceConfiguration =
2902 DAC960_V1_ReadDeviceConfiguration;
2903 Controller->ReportDeviceConfiguration =
2904 DAC960_V1_ReportDeviceConfiguration;
2905 Controller->QueueReadWriteCommand =
2906 DAC960_V1_QueueReadWriteCommand;
2907 break;
2908 case DAC960_PG_Controller:
2909 DAC960_PG_DisableInterrupts(BaseAddress);
2910 DAC960_PG_AcknowledgeHardwareMailboxStatus(BaseAddress);
2911 udelay(1000);
2912 while (DAC960_PG_InitializationInProgressP(BaseAddress))
2914 if (DAC960_PG_ReadErrorStatus(BaseAddress, &ErrorStatus,
2915 &Parameter0, &Parameter1) &&
2916 DAC960_ReportErrorStatus(Controller, ErrorStatus,
2917 Parameter0, Parameter1))
2918 goto Failure;
2919 udelay(10);
2921 if (!DAC960_V1_EnableMemoryMailboxInterface(Controller))
2923 DAC960_Error("Unable to Enable Memory Mailbox Interface "
2924 "for Controller at\n", Controller);
2925 goto Failure;
2927 DAC960_PG_EnableInterrupts(BaseAddress);
2928 if (Controller->V1.DualModeMemoryMailboxInterface)
2929 Controller->QueueCommand = DAC960_PG_QueueCommandDualMode;
2930 else Controller->QueueCommand = DAC960_PG_QueueCommandSingleMode;
2931 Controller->ReadControllerConfiguration =
2932 DAC960_V1_ReadControllerConfiguration;
2933 Controller->ReadDeviceConfiguration =
2934 DAC960_V1_ReadDeviceConfiguration;
2935 Controller->ReportDeviceConfiguration =
2936 DAC960_V1_ReportDeviceConfiguration;
2937 Controller->QueueReadWriteCommand =
2938 DAC960_V1_QueueReadWriteCommand;
2939 break;
2940 case DAC960_PD_Controller:
2941 if (!request_region(Controller->IO_Address, 0x80,
2942 Controller->FullModelName)) {
2943 DAC960_Error("IO port 0x%d busy for Controller at\n",
2944 Controller, Controller->IO_Address);
2945 goto Failure;
2947 DAC960_PD_DisableInterrupts(BaseAddress);
2948 DAC960_PD_AcknowledgeStatus(BaseAddress);
2949 udelay(1000);
2950 while (DAC960_PD_InitializationInProgressP(BaseAddress))
2952 if (DAC960_PD_ReadErrorStatus(BaseAddress, &ErrorStatus,
2953 &Parameter0, &Parameter1) &&
2954 DAC960_ReportErrorStatus(Controller, ErrorStatus,
2955 Parameter0, Parameter1))
2956 goto Failure;
2957 udelay(10);
2959 if (!DAC960_V1_EnableMemoryMailboxInterface(Controller))
2961 DAC960_Error("Unable to allocate DMA mapped memory "
2962 "for Controller at\n", Controller);
2963 goto Failure;
2965 DAC960_PD_EnableInterrupts(BaseAddress);
2966 Controller->QueueCommand = DAC960_PD_QueueCommand;
2967 Controller->ReadControllerConfiguration =
2968 DAC960_V1_ReadControllerConfiguration;
2969 Controller->ReadDeviceConfiguration =
2970 DAC960_V1_ReadDeviceConfiguration;
2971 Controller->ReportDeviceConfiguration =
2972 DAC960_V1_ReportDeviceConfiguration;
2973 Controller->QueueReadWriteCommand =
2974 DAC960_V1_QueueReadWriteCommand;
2975 break;
2976 case DAC960_P_Controller:
2977 if (!request_region(Controller->IO_Address, 0x80,
2978 Controller->FullModelName)){
2979 DAC960_Error("IO port 0x%d busy for Controller at\n",
2980 Controller, Controller->IO_Address);
2981 goto Failure;
2983 DAC960_PD_DisableInterrupts(BaseAddress);
2984 DAC960_PD_AcknowledgeStatus(BaseAddress);
2985 udelay(1000);
2986 while (DAC960_PD_InitializationInProgressP(BaseAddress))
2988 if (DAC960_PD_ReadErrorStatus(BaseAddress, &ErrorStatus,
2989 &Parameter0, &Parameter1) &&
2990 DAC960_ReportErrorStatus(Controller, ErrorStatus,
2991 Parameter0, Parameter1))
2992 goto Failure;
2993 udelay(10);
2995 if (!DAC960_V1_EnableMemoryMailboxInterface(Controller))
2997 DAC960_Error("Unable to allocate DMA mapped memory"
2998 "for Controller at\n", Controller);
2999 goto Failure;
3001 DAC960_PD_EnableInterrupts(BaseAddress);
3002 Controller->QueueCommand = DAC960_P_QueueCommand;
3003 Controller->ReadControllerConfiguration =
3004 DAC960_V1_ReadControllerConfiguration;
3005 Controller->ReadDeviceConfiguration =
3006 DAC960_V1_ReadDeviceConfiguration;
3007 Controller->ReportDeviceConfiguration =
3008 DAC960_V1_ReportDeviceConfiguration;
3009 Controller->QueueReadWriteCommand =
3010 DAC960_V1_QueueReadWriteCommand;
3011 break;
3013 /*
3014 Acquire shared access to the IRQ Channel.
3015 */
3016 IRQ_Channel = PCI_Device->irq;
3017 if (request_irq(IRQ_Channel, InterruptHandler, IRQF_SHARED,
3018 Controller->FullModelName, Controller) < 0)
3020 DAC960_Error("Unable to acquire IRQ Channel %d for Controller at\n",
3021 Controller, Controller->IRQ_Channel);
3022 goto Failure;
3024 Controller->IRQ_Channel = IRQ_Channel;
3025 Controller->InitialCommand.CommandIdentifier = 1;
3026 Controller->InitialCommand.Controller = Controller;
3027 Controller->Commands[0] = &Controller->InitialCommand;
3028 Controller->FreeCommands = &Controller->InitialCommand;
3029 return Controller;
3031 Failure:
3032 if (Controller->IO_Address == 0)
3033 DAC960_Error("PCI Bus %d Device %d Function %d I/O Address N/A "
3034 "PCI Address 0x%X\n", Controller,
3035 Controller->Bus, Controller->Device,
3036 Controller->Function, Controller->PCI_Address);
3037 else
3038 DAC960_Error("PCI Bus %d Device %d Function %d I/O Address "
3039 "0x%X PCI Address 0x%X\n", Controller,
3040 Controller->Bus, Controller->Device,
3041 Controller->Function, Controller->IO_Address,
3042 Controller->PCI_Address);
3043 DAC960_DetectCleanup(Controller);
3044 DAC960_ControllerCount--;
3045 return NULL;
3048 /*
3049 DAC960_InitializeController initializes Controller.
3050 */
3052 static boolean
3053 DAC960_InitializeController(DAC960_Controller_T *Controller)
3055 if (DAC960_ReadControllerConfiguration(Controller) &&
3056 DAC960_ReportControllerConfiguration(Controller) &&
3057 DAC960_CreateAuxiliaryStructures(Controller) &&
3058 DAC960_ReadDeviceConfiguration(Controller) &&
3059 DAC960_ReportDeviceConfiguration(Controller) &&
3060 DAC960_RegisterBlockDevice(Controller))
3062 /*
3063 Initialize the Monitoring Timer.
3064 */
3065 init_timer(&Controller->MonitoringTimer);
3066 Controller->MonitoringTimer.expires =
3067 jiffies + DAC960_MonitoringTimerInterval;
3068 Controller->MonitoringTimer.data = (unsigned long) Controller;
3069 Controller->MonitoringTimer.function = DAC960_MonitoringTimerFunction;
3070 add_timer(&Controller->MonitoringTimer);
3071 Controller->ControllerInitialized = true;
3072 return true;
3074 return false;
3078 /*
3079 DAC960_FinalizeController finalizes Controller.
3080 */
3082 static void DAC960_FinalizeController(DAC960_Controller_T *Controller)
3084 if (Controller->ControllerInitialized)
3086 unsigned long flags;
3088 /*
3089 * Acquiring and releasing lock here eliminates
3090 * a very low probability race.
3092 * The code below allocates controller command structures
3093 * from the free list without holding the controller lock.
3094 * This is safe assuming there is no other activity on
3095 * the controller at the time.
3097 * But, there might be a monitoring command still
3098 * in progress. Setting the Shutdown flag while holding
3099 * the lock ensures that there is no monitoring command
3100 * in the interrupt handler currently, and any monitoring
3101 * commands that complete from this time on will NOT return
3102 * their command structure to the free list.
3103 */
3105 spin_lock_irqsave(&Controller->queue_lock, flags);
3106 Controller->ShutdownMonitoringTimer = 1;
3107 spin_unlock_irqrestore(&Controller->queue_lock, flags);
3109 del_timer_sync(&Controller->MonitoringTimer);
3110 if (Controller->FirmwareType == DAC960_V1_Controller)
3112 DAC960_Notice("Flushing Cache...", Controller);
3113 DAC960_V1_ExecuteType3(Controller, DAC960_V1_Flush, 0);
3114 DAC960_Notice("done\n", Controller);
3116 if (Controller->HardwareType == DAC960_PD_Controller)
3117 release_region(Controller->IO_Address, 0x80);
3119 else
3121 DAC960_Notice("Flushing Cache...", Controller);
3122 DAC960_V2_DeviceOperation(Controller, DAC960_V2_PauseDevice,
3123 DAC960_V2_RAID_Controller);
3124 DAC960_Notice("done\n", Controller);
3127 DAC960_UnregisterBlockDevice(Controller);
3128 DAC960_DestroyAuxiliaryStructures(Controller);
3129 DAC960_DestroyProcEntries(Controller);
3130 DAC960_DetectCleanup(Controller);
3134 /*
3135 DAC960_Probe verifies controller's existence and
3136 initializes the DAC960 Driver for that controller.
3137 */
3139 static int
3140 DAC960_Probe(struct pci_dev *dev, const struct pci_device_id *entry)
3142 int disk;
3143 DAC960_Controller_T *Controller;
3145 if (DAC960_ControllerCount == DAC960_MaxControllers)
3147 DAC960_Error("More than %d DAC960 Controllers detected - "
3148 "ignoring from Controller at\n",
3149 NULL, DAC960_MaxControllers);
3150 return -ENODEV;
3153 Controller = DAC960_DetectController(dev, entry);
3154 if (!Controller)
3155 return -ENODEV;
3157 if (!DAC960_InitializeController(Controller)) {
3158 DAC960_FinalizeController(Controller);
3159 return -ENODEV;
3162 for (disk = 0; disk < DAC960_MaxLogicalDrives; disk++) {
3163 set_capacity(Controller->disks[disk], disk_size(Controller, disk));
3164 add_disk(Controller->disks[disk]);
3166 DAC960_CreateProcEntries(Controller);
3167 return 0;
3171 /*
3172 DAC960_Finalize finalizes the DAC960 Driver.
3173 */
3175 static void DAC960_Remove(struct pci_dev *PCI_Device)
3177 int Controller_Number = (long)pci_get_drvdata(PCI_Device);
3178 DAC960_Controller_T *Controller = DAC960_Controllers[Controller_Number];
3179 if (Controller != NULL)
3180 DAC960_FinalizeController(Controller);
3184 /*
3185 DAC960_V1_QueueReadWriteCommand prepares and queues a Read/Write Command for
3186 DAC960 V1 Firmware Controllers.
3187 */
3189 static void DAC960_V1_QueueReadWriteCommand(DAC960_Command_T *Command)
3191 DAC960_Controller_T *Controller = Command->Controller;
3192 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
3193 DAC960_V1_ScatterGatherSegment_T *ScatterGatherList =
3194 Command->V1.ScatterGatherList;
3195 struct scatterlist *ScatterList = Command->V1.ScatterList;
3197 DAC960_V1_ClearCommand(Command);
3199 if (Command->SegmentCount == 1)
3201 if (Command->DmaDirection == PCI_DMA_FROMDEVICE)
3202 CommandMailbox->Type5.CommandOpcode = DAC960_V1_Read;
3203 else
3204 CommandMailbox->Type5.CommandOpcode = DAC960_V1_Write;
3206 CommandMailbox->Type5.LD.TransferLength = Command->BlockCount;
3207 CommandMailbox->Type5.LD.LogicalDriveNumber = Command->LogicalDriveNumber;
3208 CommandMailbox->Type5.LogicalBlockAddress = Command->BlockNumber;
3209 CommandMailbox->Type5.BusAddress =
3210 (DAC960_BusAddress32_T)sg_dma_address(ScatterList);
3212 else
3214 int i;
3216 if (Command->DmaDirection == PCI_DMA_FROMDEVICE)
3217 CommandMailbox->Type5.CommandOpcode = DAC960_V1_ReadWithScatterGather;
3218 else
3219 CommandMailbox->Type5.CommandOpcode = DAC960_V1_WriteWithScatterGather;
3221 CommandMailbox->Type5.LD.TransferLength = Command->BlockCount;
3222 CommandMailbox->Type5.LD.LogicalDriveNumber = Command->LogicalDriveNumber;
3223 CommandMailbox->Type5.LogicalBlockAddress = Command->BlockNumber;
3224 CommandMailbox->Type5.BusAddress = Command->V1.ScatterGatherListDMA;
3226 CommandMailbox->Type5.ScatterGatherCount = Command->SegmentCount;
3228 for (i = 0; i < Command->SegmentCount; i++, ScatterList++, ScatterGatherList++) {
3229 ScatterGatherList->SegmentDataPointer =
3230 (DAC960_BusAddress32_T)sg_dma_address(ScatterList);
3231 ScatterGatherList->SegmentByteCount =
3232 (DAC960_ByteCount32_T)sg_dma_len(ScatterList);
3235 DAC960_QueueCommand(Command);
3239 /*
3240 DAC960_V2_QueueReadWriteCommand prepares and queues a Read/Write Command for
3241 DAC960 V2 Firmware Controllers.
3242 */
3244 static void DAC960_V2_QueueReadWriteCommand(DAC960_Command_T *Command)
3246 DAC960_Controller_T *Controller = Command->Controller;
3247 DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
3248 struct scatterlist *ScatterList = Command->V2.ScatterList;
3250 DAC960_V2_ClearCommand(Command);
3252 CommandMailbox->SCSI_10.CommandOpcode = DAC960_V2_SCSI_10;
3253 CommandMailbox->SCSI_10.CommandControlBits.DataTransferControllerToHost =
3254 (Command->DmaDirection == PCI_DMA_FROMDEVICE);
3255 CommandMailbox->SCSI_10.DataTransferSize =
3256 Command->BlockCount << DAC960_BlockSizeBits;
3257 CommandMailbox->SCSI_10.RequestSenseBusAddress = Command->V2.RequestSenseDMA;
3258 CommandMailbox->SCSI_10.PhysicalDevice =
3259 Controller->V2.LogicalDriveToVirtualDevice[Command->LogicalDriveNumber];
3260 CommandMailbox->SCSI_10.RequestSenseSize = sizeof(DAC960_SCSI_RequestSense_T);
3261 CommandMailbox->SCSI_10.CDBLength = 10;
3262 CommandMailbox->SCSI_10.SCSI_CDB[0] =
3263 (Command->DmaDirection == PCI_DMA_FROMDEVICE ? 0x28 : 0x2A);
3264 CommandMailbox->SCSI_10.SCSI_CDB[2] = Command->BlockNumber >> 24;
3265 CommandMailbox->SCSI_10.SCSI_CDB[3] = Command->BlockNumber >> 16;
3266 CommandMailbox->SCSI_10.SCSI_CDB[4] = Command->BlockNumber >> 8;
3267 CommandMailbox->SCSI_10.SCSI_CDB[5] = Command->BlockNumber;
3268 CommandMailbox->SCSI_10.SCSI_CDB[7] = Command->BlockCount >> 8;
3269 CommandMailbox->SCSI_10.SCSI_CDB[8] = Command->BlockCount;
3271 if (Command->SegmentCount == 1)
3273 CommandMailbox->SCSI_10.DataTransferMemoryAddress
3274 .ScatterGatherSegments[0]
3275 .SegmentDataPointer =
3276 (DAC960_BusAddress64_T)sg_dma_address(ScatterList);
3277 CommandMailbox->SCSI_10.DataTransferMemoryAddress
3278 .ScatterGatherSegments[0]
3279 .SegmentByteCount =
3280 CommandMailbox->SCSI_10.DataTransferSize;
3282 else
3284 DAC960_V2_ScatterGatherSegment_T *ScatterGatherList;
3285 int i;
3287 if (Command->SegmentCount > 2)
3289 ScatterGatherList = Command->V2.ScatterGatherList;
3290 CommandMailbox->SCSI_10.CommandControlBits
3291 .AdditionalScatterGatherListMemory = true;
3292 CommandMailbox->SCSI_10.DataTransferMemoryAddress
3293 .ExtendedScatterGather.ScatterGatherList0Length = Command->SegmentCount;
3294 CommandMailbox->SCSI_10.DataTransferMemoryAddress
3295 .ExtendedScatterGather.ScatterGatherList0Address =
3296 Command->V2.ScatterGatherListDMA;
3298 else
3299 ScatterGatherList = CommandMailbox->SCSI_10.DataTransferMemoryAddress
3300 .ScatterGatherSegments;
3302 for (i = 0; i < Command->SegmentCount; i++, ScatterList++, ScatterGatherList++) {
3303 ScatterGatherList->SegmentDataPointer =
3304 (DAC960_BusAddress64_T)sg_dma_address(ScatterList);
3305 ScatterGatherList->SegmentByteCount =
3306 (DAC960_ByteCount64_T)sg_dma_len(ScatterList);
3309 DAC960_QueueCommand(Command);
3313 static int DAC960_process_queue(DAC960_Controller_T *Controller, struct request_queue *req_q)
3315 struct request *Request;
3316 DAC960_Command_T *Command;
3318 while(1) {
3319 Request = elv_next_request(req_q);
3320 if (!Request)
3321 return 1;
3323 Command = DAC960_AllocateCommand(Controller);
3324 if (Command == NULL)
3325 return 0;
3327 if (rq_data_dir(Request) == READ) {
3328 Command->DmaDirection = PCI_DMA_FROMDEVICE;
3329 Command->CommandType = DAC960_ReadCommand;
3330 } else {
3331 Command->DmaDirection = PCI_DMA_TODEVICE;
3332 Command->CommandType = DAC960_WriteCommand;
3334 Command->Completion = Request->waiting;
3335 Command->LogicalDriveNumber = (long)Request->rq_disk->private_data;
3336 Command->BlockNumber = Request->sector;
3337 Command->BlockCount = Request->nr_sectors;
3338 Command->Request = Request;
3339 blkdev_dequeue_request(Request);
3340 Command->SegmentCount = blk_rq_map_sg(req_q,
3341 Command->Request, Command->cmd_sglist);
3342 /* pci_map_sg MAY change the value of SegCount */
3343 Command->SegmentCount = pci_map_sg(Controller->PCIDevice, Command->cmd_sglist,
3344 Command->SegmentCount, Command->DmaDirection);
3346 DAC960_QueueReadWriteCommand(Command);
3350 /*
3351 DAC960_ProcessRequest attempts to remove one I/O Request from Controller's
3352 I/O Request Queue and queues it to the Controller. WaitForCommand is true if
3353 this function should wait for a Command to become available if necessary.
3354 This function returns true if an I/O Request was queued and false otherwise.
3355 */
3356 static void DAC960_ProcessRequest(DAC960_Controller_T *controller)
3358 int i;
3360 if (!controller->ControllerInitialized)
3361 return;
3363 /* Do this better later! */
3364 for (i = controller->req_q_index; i < DAC960_MaxLogicalDrives; i++) {
3365 struct request_queue *req_q = controller->RequestQueue[i];
3367 if (req_q == NULL)
3368 continue;
3370 if (!DAC960_process_queue(controller, req_q)) {
3371 controller->req_q_index = i;
3372 return;
3376 if (controller->req_q_index == 0)
3377 return;
3379 for (i = 0; i < controller->req_q_index; i++) {
3380 struct request_queue *req_q = controller->RequestQueue[i];
3382 if (req_q == NULL)
3383 continue;
3385 if (!DAC960_process_queue(controller, req_q)) {
3386 controller->req_q_index = i;
3387 return;
3393 /*
3394 DAC960_queue_partial_rw extracts one bio from the request already
3395 associated with argument command, and construct a new command block to retry I/O
3396 only on that bio. Queue that command to the controller.
3398 This function re-uses a previously-allocated Command,
3399 there is no failure mode from trying to allocate a command.
3400 */
3402 static void DAC960_queue_partial_rw(DAC960_Command_T *Command)
3404 DAC960_Controller_T *Controller = Command->Controller;
3405 struct request *Request = Command->Request;
3406 struct request_queue *req_q = Controller->RequestQueue[Command->LogicalDriveNumber];
3408 if (Command->DmaDirection == PCI_DMA_FROMDEVICE)
3409 Command->CommandType = DAC960_ReadRetryCommand;
3410 else
3411 Command->CommandType = DAC960_WriteRetryCommand;
3413 /*
3414 * We could be more efficient with these mapping requests
3415 * and map only the portions that we need. But since this
3416 * code should almost never be called, just go with a
3417 * simple coding.
3418 */
3419 (void)blk_rq_map_sg(req_q, Command->Request, Command->cmd_sglist);
3421 (void)pci_map_sg(Controller->PCIDevice, Command->cmd_sglist, 1, Command->DmaDirection);
3422 /*
3423 * Resubmitting the request sector at a time is really tedious.
3424 * But, this should almost never happen. So, we're willing to pay
3425 * this price so that in the end, as much of the transfer is completed
3426 * successfully as possible.
3427 */
3428 Command->SegmentCount = 1;
3429 Command->BlockNumber = Request->sector;
3430 Command->BlockCount = 1;
3431 DAC960_QueueReadWriteCommand(Command);
3432 return;
3435 /*
3436 DAC960_RequestFunction is the I/O Request Function for DAC960 Controllers.
3437 */
3439 static void DAC960_RequestFunction(struct request_queue *RequestQueue)
3441 DAC960_ProcessRequest(RequestQueue->queuedata);
3444 /*
3445 DAC960_ProcessCompletedBuffer performs completion processing for an
3446 individual Buffer.
3447 */
3449 static inline boolean DAC960_ProcessCompletedRequest(DAC960_Command_T *Command,
3450 boolean SuccessfulIO)
3452 struct request *Request = Command->Request;
3453 int UpToDate;
3455 UpToDate = 0;
3456 if (SuccessfulIO)
3457 UpToDate = 1;
3459 pci_unmap_sg(Command->Controller->PCIDevice, Command->cmd_sglist,
3460 Command->SegmentCount, Command->DmaDirection);
3462 if (!end_that_request_first(Request, UpToDate, Command->BlockCount)) {
3463 add_disk_randomness(Request->rq_disk);
3464 end_that_request_last(Request, UpToDate);
3466 if (Command->Completion) {
3467 complete(Command->Completion);
3468 Command->Completion = NULL;
3470 return true;
3472 return false;
3475 /*
3476 DAC960_V1_ReadWriteError prints an appropriate error message for Command
3477 when an error occurs on a Read or Write operation.
3478 */
3480 static void DAC960_V1_ReadWriteError(DAC960_Command_T *Command)
3482 DAC960_Controller_T *Controller = Command->Controller;
3483 unsigned char *CommandName = "UNKNOWN";
3484 switch (Command->CommandType)
3486 case DAC960_ReadCommand:
3487 case DAC960_ReadRetryCommand:
3488 CommandName = "READ";
3489 break;
3490 case DAC960_WriteCommand:
3491 case DAC960_WriteRetryCommand:
3492 CommandName = "WRITE";
3493 break;
3494 case DAC960_MonitoringCommand:
3495 case DAC960_ImmediateCommand:
3496 case DAC960_QueuedCommand:
3497 break;
3499 switch (Command->V1.CommandStatus)
3501 case DAC960_V1_IrrecoverableDataError:
3502 DAC960_Error("Irrecoverable Data Error on %s:\n",
3503 Controller, CommandName);
3504 break;
3505 case DAC960_V1_LogicalDriveNonexistentOrOffline:
3506 DAC960_Error("Logical Drive Nonexistent or Offline on %s:\n",
3507 Controller, CommandName);
3508 break;
3509 case DAC960_V1_AccessBeyondEndOfLogicalDrive:
3510 DAC960_Error("Attempt to Access Beyond End of Logical Drive "
3511 "on %s:\n", Controller, CommandName);
3512 break;
3513 case DAC960_V1_BadDataEncountered:
3514 DAC960_Error("Bad Data Encountered on %s:\n", Controller, CommandName);
3515 break;
3516 default:
3517 DAC960_Error("Unexpected Error Status %04X on %s:\n",
3518 Controller, Command->V1.CommandStatus, CommandName);
3519 break;
3521 DAC960_Error(" /dev/rd/c%dd%d: absolute blocks %u..%u\n",
3522 Controller, Controller->ControllerNumber,
3523 Command->LogicalDriveNumber, Command->BlockNumber,
3524 Command->BlockNumber + Command->BlockCount - 1);
3528 /*
3529 DAC960_V1_ProcessCompletedCommand performs completion processing for Command
3530 for DAC960 V1 Firmware Controllers.
3531 */
3533 static void DAC960_V1_ProcessCompletedCommand(DAC960_Command_T *Command)
3535 DAC960_Controller_T *Controller = Command->Controller;
3536 DAC960_CommandType_T CommandType = Command->CommandType;
3537 DAC960_V1_CommandOpcode_T CommandOpcode =
3538 Command->V1.CommandMailbox.Common.CommandOpcode;
3539 DAC960_V1_CommandStatus_T CommandStatus = Command->V1.CommandStatus;
3541 if (CommandType == DAC960_ReadCommand ||
3542 CommandType == DAC960_WriteCommand)
3545 #ifdef FORCE_RETRY_DEBUG
3546 CommandStatus = DAC960_V1_IrrecoverableDataError;
3547 #endif
3549 if (CommandStatus == DAC960_V1_NormalCompletion) {
3551 if (!DAC960_ProcessCompletedRequest(Command, true))
3552 BUG();
3554 } else if (CommandStatus == DAC960_V1_IrrecoverableDataError ||
3555 CommandStatus == DAC960_V1_BadDataEncountered)
3557 /*
3558 * break the command down into pieces and resubmit each
3559 * piece, hoping that some of them will succeed.
3560 */
3561 DAC960_queue_partial_rw(Command);
3562 return;
3564 else
3566 if (CommandStatus != DAC960_V1_LogicalDriveNonexistentOrOffline)
3567 DAC960_V1_ReadWriteError(Command);
3569 if (!DAC960_ProcessCompletedRequest(Command, false))
3570 BUG();
3573 else if (CommandType == DAC960_ReadRetryCommand ||
3574 CommandType == DAC960_WriteRetryCommand)
3576 boolean normal_completion;
3577 #ifdef FORCE_RETRY_FAILURE_DEBUG
3578 static int retry_count = 1;
3579 #endif
3580 /*
3581 Perform completion processing for the portion that was
3582 retried, and submit the next portion, if any.
3583 */
3584 normal_completion = true;
3585 if (CommandStatus != DAC960_V1_NormalCompletion) {
3586 normal_completion = false;
3587 if (CommandStatus != DAC960_V1_LogicalDriveNonexistentOrOffline)
3588 DAC960_V1_ReadWriteError(Command);
3591 #ifdef FORCE_RETRY_FAILURE_DEBUG
3592 if (!(++retry_count % 10000)) {
3593 printk("V1 error retry failure test\n");
3594 normal_completion = false;
3595 DAC960_V1_ReadWriteError(Command);
3597 #endif
3599 if (!DAC960_ProcessCompletedRequest(Command, normal_completion)) {
3600 DAC960_queue_partial_rw(Command);
3601 return;
3605 else if (CommandType == DAC960_MonitoringCommand)
3607 if (Controller->ShutdownMonitoringTimer)
3608 return;
3609 if (CommandOpcode == DAC960_V1_Enquiry)
3611 DAC960_V1_Enquiry_T *OldEnquiry = &Controller->V1.Enquiry;
3612 DAC960_V1_Enquiry_T *NewEnquiry = Controller->V1.NewEnquiry;
3613 unsigned int OldCriticalLogicalDriveCount =
3614 OldEnquiry->CriticalLogicalDriveCount;
3615 unsigned int NewCriticalLogicalDriveCount =
3616 NewEnquiry->CriticalLogicalDriveCount;
3617 if (NewEnquiry->NumberOfLogicalDrives > Controller->LogicalDriveCount)
3619 int LogicalDriveNumber = Controller->LogicalDriveCount - 1;
3620 while (++LogicalDriveNumber < NewEnquiry->NumberOfLogicalDrives)
3621 DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
3622 "Now Exists\n", Controller,
3623 LogicalDriveNumber,
3624 Controller->ControllerNumber,
3625 LogicalDriveNumber);
3626 Controller->LogicalDriveCount = NewEnquiry->NumberOfLogicalDrives;
3627 DAC960_ComputeGenericDiskInfo(Controller);
3629 if (NewEnquiry->NumberOfLogicalDrives < Controller->LogicalDriveCount)
3631 int LogicalDriveNumber = NewEnquiry->NumberOfLogicalDrives - 1;
3632 while (++LogicalDriveNumber < Controller->LogicalDriveCount)
3633 DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
3634 "No Longer Exists\n", Controller,
3635 LogicalDriveNumber,
3636 Controller->ControllerNumber,
3637 LogicalDriveNumber);
3638 Controller->LogicalDriveCount = NewEnquiry->NumberOfLogicalDrives;
3639 DAC960_ComputeGenericDiskInfo(Controller);
3641 if (NewEnquiry->StatusFlags.DeferredWriteError !=
3642 OldEnquiry->StatusFlags.DeferredWriteError)
3643 DAC960_Critical("Deferred Write Error Flag is now %s\n", Controller,
3644 (NewEnquiry->StatusFlags.DeferredWriteError
3645 ? "TRUE" : "FALSE"));
3646 if ((NewCriticalLogicalDriveCount > 0 ||
3647 NewCriticalLogicalDriveCount != OldCriticalLogicalDriveCount) ||
3648 (NewEnquiry->OfflineLogicalDriveCount > 0 ||
3649 NewEnquiry->OfflineLogicalDriveCount !=
3650 OldEnquiry->OfflineLogicalDriveCount) ||
3651 (NewEnquiry->DeadDriveCount > 0 ||
3652 NewEnquiry->DeadDriveCount !=
3653 OldEnquiry->DeadDriveCount) ||
3654 (NewEnquiry->EventLogSequenceNumber !=
3655 OldEnquiry->EventLogSequenceNumber) ||
3656 Controller->MonitoringTimerCount == 0 ||
3657 time_after_eq(jiffies, Controller->SecondaryMonitoringTime
3658 + DAC960_SecondaryMonitoringInterval))
3660 Controller->V1.NeedLogicalDriveInformation = true;
3661 Controller->V1.NewEventLogSequenceNumber =
3662 NewEnquiry->EventLogSequenceNumber;
3663 Controller->V1.NeedErrorTableInformation = true;
3664 Controller->V1.NeedDeviceStateInformation = true;
3665 Controller->V1.StartDeviceStateScan = true;
3666 Controller->V1.NeedBackgroundInitializationStatus =
3667 Controller->V1.BackgroundInitializationStatusSupported;
3668 Controller->SecondaryMonitoringTime = jiffies;
3670 if (NewEnquiry->RebuildFlag == DAC960_V1_StandbyRebuildInProgress ||
3671 NewEnquiry->RebuildFlag
3672 == DAC960_V1_BackgroundRebuildInProgress ||
3673 OldEnquiry->RebuildFlag == DAC960_V1_StandbyRebuildInProgress ||
3674 OldEnquiry->RebuildFlag == DAC960_V1_BackgroundRebuildInProgress)
3676 Controller->V1.NeedRebuildProgress = true;
3677 Controller->V1.RebuildProgressFirst =
3678 (NewEnquiry->CriticalLogicalDriveCount <
3679 OldEnquiry->CriticalLogicalDriveCount);
3681 if (OldEnquiry->RebuildFlag == DAC960_V1_BackgroundCheckInProgress)
3682 switch (NewEnquiry->RebuildFlag)
3684 case DAC960_V1_NoStandbyRebuildOrCheckInProgress:
3685 DAC960_Progress("Consistency Check Completed Successfully\n",
3686 Controller);
3687 break;
3688 case DAC960_V1_StandbyRebuildInProgress:
3689 case DAC960_V1_BackgroundRebuildInProgress:
3690 break;
3691 case DAC960_V1_BackgroundCheckInProgress:
3692 Controller->V1.NeedConsistencyCheckProgress = true;
3693 break;
3694 case DAC960_V1_StandbyRebuildCompletedWithError:
3695 DAC960_Progress("Consistency Check Completed with Error\n",
3696 Controller);
3697 break;
3698 case DAC960_V1_BackgroundRebuildOrCheckFailed_DriveFailed:
3699 DAC960_Progress("Consistency Check Failed - "
3700 "Physical Device Failed\n", Controller);
3701 break;
3702 case DAC960_V1_BackgroundRebuildOrCheckFailed_LogicalDriveFailed:
3703 DAC960_Progress("Consistency Check Failed - "
3704 "Logical Drive Failed\n", Controller);
3705 break;
3706 case DAC960_V1_BackgroundRebuildOrCheckFailed_OtherCauses:
3707 DAC960_Progress("Consistency Check Failed - Other Causes\n",
3708 Controller);
3709 break;
3710 case DAC960_V1_BackgroundRebuildOrCheckSuccessfullyTerminated:
3711 DAC960_Progress("Consistency Check Successfully Terminated\n",
3712 Controller);
3713 break;
3715 else if (NewEnquiry->RebuildFlag
3716 == DAC960_V1_BackgroundCheckInProgress)
3717 Controller->V1.NeedConsistencyCheckProgress = true;
3718 Controller->MonitoringAlertMode =
3719 (NewEnquiry->CriticalLogicalDriveCount > 0 ||
3720 NewEnquiry->OfflineLogicalDriveCount > 0 ||
3721 NewEnquiry->DeadDriveCount > 0);
3722 if (NewEnquiry->RebuildFlag > DAC960_V1_BackgroundCheckInProgress)
3724 Controller->V1.PendingRebuildFlag = NewEnquiry->RebuildFlag;
3725 Controller->V1.RebuildFlagPending = true;
3727 memcpy(&Controller->V1.Enquiry, &Controller->V1.NewEnquiry,
3728 sizeof(DAC960_V1_Enquiry_T));
3730 else if (CommandOpcode == DAC960_V1_PerformEventLogOperation)
3732 static char
3733 *DAC960_EventMessages[] =
3734 { "killed because write recovery failed",
3735 "killed because of SCSI bus reset failure",
3736 "killed because of double check condition",
3737 "killed because it was removed",
3738 "killed because of gross error on SCSI chip",
3739 "killed because of bad tag returned from drive",
3740 "killed because of timeout on SCSI command",
3741 "killed because of reset SCSI command issued from system",
3742 "killed because busy or parity error count exceeded limit",
3743 "killed because of 'kill drive' command from system",
3744 "killed because of selection timeout",
3745 "killed due to SCSI phase sequence error",
3746 "killed due to unknown status" };
3747 DAC960_V1_EventLogEntry_T *EventLogEntry =
3748 Controller->V1.EventLogEntry;
3749 if (EventLogEntry->SequenceNumber ==
3750 Controller->V1.OldEventLogSequenceNumber)
3752 unsigned char SenseKey = EventLogEntry->SenseKey;
3753 unsigned char AdditionalSenseCode =
3754 EventLogEntry->AdditionalSenseCode;
3755 unsigned char AdditionalSenseCodeQualifier =
3756 EventLogEntry->AdditionalSenseCodeQualifier;
3757 if (SenseKey == DAC960_SenseKey_VendorSpecific &&
3758 AdditionalSenseCode == 0x80 &&
3759 AdditionalSenseCodeQualifier <
3760 ARRAY_SIZE(DAC960_EventMessages))
3761 DAC960_Critical("Physical Device %d:%d %s\n", Controller,
3762 EventLogEntry->Channel,
3763 EventLogEntry->TargetID,
3764 DAC960_EventMessages[
3765 AdditionalSenseCodeQualifier]);
3766 else if (SenseKey == DAC960_SenseKey_UnitAttention &&
3767 AdditionalSenseCode == 0x29)
3769 if (Controller->MonitoringTimerCount > 0)
3770 Controller->V1.DeviceResetCount[EventLogEntry->Channel]
3771 [EventLogEntry->TargetID]++;
3773 else if (!(SenseKey == DAC960_SenseKey_NoSense ||
3774 (SenseKey == DAC960_SenseKey_NotReady &&
3775 AdditionalSenseCode == 0x04 &&
3776 (AdditionalSenseCodeQualifier == 0x01 ||
3777 AdditionalSenseCodeQualifier == 0x02))))
3779 DAC960_Critical("Physical Device %d:%d Error Log: "
3780 "Sense Key = %X, ASC = %02X, ASCQ = %02X\n",
3781 Controller,
3782 EventLogEntry->Channel,
3783 EventLogEntry->TargetID,
3784 SenseKey,
3785 AdditionalSenseCode,
3786 AdditionalSenseCodeQualifier);
3787 DAC960_Critical("Physical Device %d:%d Error Log: "
3788 "Information = %02X%02X%02X%02X "
3789 "%02X%02X%02X%02X\n",
3790 Controller,
3791 EventLogEntry->Channel,
3792 EventLogEntry->TargetID,
3793 EventLogEntry->Information[0],
3794 EventLogEntry->Information[1],
3795 EventLogEntry->Information[2],
3796 EventLogEntry->Information[3],
3797 EventLogEntry->CommandSpecificInformation[0],
3798 EventLogEntry->CommandSpecificInformation[1],
3799 EventLogEntry->CommandSpecificInformation[2],
3800 EventLogEntry->CommandSpecificInformation[3]);
3803 Controller->V1.OldEventLogSequenceNumber++;
3805 else if (CommandOpcode == DAC960_V1_GetErrorTable)
3807 DAC960_V1_ErrorTable_T *OldErrorTable = &Controller->V1.ErrorTable;
3808 DAC960_V1_ErrorTable_T *NewErrorTable = Controller->V1.NewErrorTable;
3809 int Channel, TargetID;
3810 for (Channel = 0; Channel < Controller->Channels; Channel++)
3811 for (TargetID = 0; TargetID < Controller->Targets; TargetID++)
3813 DAC960_V1_ErrorTableEntry_T *NewErrorEntry =
3814 &NewErrorTable->ErrorTableEntries[Channel][TargetID];
3815 DAC960_V1_ErrorTableEntry_T *OldErrorEntry =
3816 &OldErrorTable->ErrorTableEntries[Channel][TargetID];
3817 if ((NewErrorEntry->ParityErrorCount !=
3818 OldErrorEntry->ParityErrorCount) ||
3819 (NewErrorEntry->SoftErrorCount !=
3820 OldErrorEntry->SoftErrorCount) ||
3821 (NewErrorEntry->HardErrorCount !=
3822 OldErrorEntry->HardErrorCount) ||
3823 (NewErrorEntry->MiscErrorCount !=
3824 OldErrorEntry->MiscErrorCount))
3825 DAC960_Critical("Physical Device %d:%d Errors: "
3826 "Parity = %d, Soft = %d, "
3827 "Hard = %d, Misc = %d\n",
3828 Controller, Channel, TargetID,
3829 NewErrorEntry->ParityErrorCount,
3830 NewErrorEntry->SoftErrorCount,
3831 NewErrorEntry->HardErrorCount,
3832 NewErrorEntry->MiscErrorCount);
3834 memcpy(&Controller->V1.ErrorTable, Controller->V1.NewErrorTable,
3835 sizeof(DAC960_V1_ErrorTable_T));
3837 else if (CommandOpcode == DAC960_V1_GetDeviceState)
3839 DAC960_V1_DeviceState_T *OldDeviceState =
3840 &Controller->V1.DeviceState[Controller->V1.DeviceStateChannel]
3841 [Controller->V1.DeviceStateTargetID];
3842 DAC960_V1_DeviceState_T *NewDeviceState =
3843 Controller->V1.NewDeviceState;
3844 if (NewDeviceState->DeviceState != OldDeviceState->DeviceState)
3845 DAC960_Critical("Physical Device %d:%d is now %s\n", Controller,
3846 Controller->V1.DeviceStateChannel,
3847 Controller->V1.DeviceStateTargetID,
3848 (NewDeviceState->DeviceState
3849 == DAC960_V1_Device_Dead
3850 ? "DEAD"
3851 : NewDeviceState->DeviceState
3852 == DAC960_V1_Device_WriteOnly
3853 ? "WRITE-ONLY"
3854 : NewDeviceState->DeviceState
3855 == DAC960_V1_Device_Online
3856 ? "ONLINE" : "STANDBY"));
3857 if (OldDeviceState->DeviceState == DAC960_V1_Device_Dead &&
3858 NewDeviceState->DeviceState != DAC960_V1_Device_Dead)
3860 Controller->V1.NeedDeviceInquiryInformation = true;
3861 Controller->V1.NeedDeviceSerialNumberInformation = true;
3862 Controller->V1.DeviceResetCount
3863 [Controller->V1.DeviceStateChannel]
3864 [Controller->V1.DeviceStateTargetID] = 0;
3866 memcpy(OldDeviceState, NewDeviceState,
3867 sizeof(DAC960_V1_DeviceState_T));
3869 else if (CommandOpcode == DAC960_V1_GetLogicalDriveInformation)
3871 int LogicalDriveNumber;
3872 for (LogicalDriveNumber = 0;
3873 LogicalDriveNumber < Controller->LogicalDriveCount;
3874 LogicalDriveNumber++)
3876 DAC960_V1_LogicalDriveInformation_T *OldLogicalDriveInformation =
3877 &Controller->V1.LogicalDriveInformation[LogicalDriveNumber];
3878 DAC960_V1_LogicalDriveInformation_T *NewLogicalDriveInformation =
3879 &(*Controller->V1.NewLogicalDriveInformation)[LogicalDriveNumber];
3880 if (NewLogicalDriveInformation->LogicalDriveState !=
3881 OldLogicalDriveInformation->LogicalDriveState)
3882 DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
3883 "is now %s\n", Controller,
3884 LogicalDriveNumber,
3885 Controller->ControllerNumber,
3886 LogicalDriveNumber,
3887 (NewLogicalDriveInformation->LogicalDriveState
3888 == DAC960_V1_LogicalDrive_Online
3889 ? "ONLINE"
3890 : NewLogicalDriveInformation->LogicalDriveState
3891 == DAC960_V1_LogicalDrive_Critical
3892 ? "CRITICAL" : "OFFLINE"));
3893 if (NewLogicalDriveInformation->WriteBack !=
3894 OldLogicalDriveInformation->WriteBack)
3895 DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
3896 "is now %s\n", Controller,
3897 LogicalDriveNumber,
3898 Controller->ControllerNumber,
3899 LogicalDriveNumber,
3900 (NewLogicalDriveInformation->WriteBack
3901 ? "WRITE BACK" : "WRITE THRU"));
3903 memcpy(&Controller->V1.LogicalDriveInformation,
3904 Controller->V1.NewLogicalDriveInformation,
3905 sizeof(DAC960_V1_LogicalDriveInformationArray_T));
3907 else if (CommandOpcode == DAC960_V1_GetRebuildProgress)
3909 unsigned int LogicalDriveNumber =
3910 Controller->V1.RebuildProgress->LogicalDriveNumber;
3911 unsigned int LogicalDriveSize =
3912 Controller->V1.RebuildProgress->LogicalDriveSize;
3913 unsigned int BlocksCompleted =
3914 LogicalDriveSize - Controller->V1.RebuildProgress->RemainingBlocks;
3915 if (CommandStatus == DAC960_V1_NoRebuildOrCheckInProgress &&
3916 Controller->V1.LastRebuildStatus == DAC960_V1_NormalCompletion)
3917 CommandStatus = DAC960_V1_RebuildSuccessful;
3918 switch (CommandStatus)
3920 case DAC960_V1_NormalCompletion:
3921 Controller->EphemeralProgressMessage = true;
3922 DAC960_Progress("Rebuild in Progress: "
3923 "Logical Drive %d (/dev/rd/c%dd%d) "
3924 "%d%% completed\n",
3925 Controller, LogicalDriveNumber,
3926 Controller->ControllerNumber,
3927 LogicalDriveNumber,
3928 (100 * (BlocksCompleted >> 7))
3929 / (LogicalDriveSize >> 7));
3930 Controller->EphemeralProgressMessage = false;
3931 break;
3932 case DAC960_V1_RebuildFailed_LogicalDriveFailure:
3933 DAC960_Progress("Rebuild Failed due to "
3934 "Logical Drive Failure\n", Controller);
3935 break;
3936 case DAC960_V1_RebuildFailed_BadBlocksOnOther:
3937 DAC960_Progress("Rebuild Failed due to "
3938 "Bad Blocks on Other Drives\n", Controller);
3939 break;
3940 case DAC960_V1_RebuildFailed_NewDriveFailed:
3941 DAC960_Progress("Rebuild Failed due to "
3942 "Failure of Drive Being Rebuilt\n", Controller);
3943 break;
3944 case DAC960_V1_NoRebuildOrCheckInProgress:
3945 break;
3946 case DAC960_V1_RebuildSuccessful:
3947 DAC960_Progress("Rebuild Completed Successfully\n", Controller);
3948 break;
3949 case DAC960_V1_RebuildSuccessfullyTerminated:
3950 DAC960_Progress("Rebuild Successfully Terminated\n", Controller);
3951 break;
3953 Controller->V1.LastRebuildStatus = CommandStatus;
3954 if (CommandType != DAC960_MonitoringCommand &&
3955 Controller->V1.RebuildStatusPending)
3957 Command->V1.CommandStatus = Controller->V1.PendingRebuildStatus;
3958 Controller->V1.RebuildStatusPending = false;
3960 else if (CommandType == DAC960_MonitoringCommand &&
3961 CommandStatus != DAC960_V1_NormalCompletion &&
3962 CommandStatus != DAC960_V1_NoRebuildOrCheckInProgress)
3964 Controller->V1.PendingRebuildStatus = CommandStatus;
3965 Controller->V1.RebuildStatusPending = true;
3968 else if (CommandOpcode == DAC960_V1_RebuildStat)
3970 unsigned int LogicalDriveNumber =
3971 Controller->V1.RebuildProgress->LogicalDriveNumber;
3972 unsigned int LogicalDriveSize =
3973 Controller->V1.RebuildProgress->LogicalDriveSize;
3974 unsigned int BlocksCompleted =
3975 LogicalDriveSize - Controller->V1.RebuildProgress->RemainingBlocks;
3976 if (CommandStatus == DAC960_V1_NormalCompletion)
3978 Controller->EphemeralProgressMessage = true;
3979 DAC960_Progress("Consistency Check in Progress: "
3980 "Logical Drive %d (/dev/rd/c%dd%d) "
3981 "%d%% completed\n",
3982 Controller, LogicalDriveNumber,
3983 Controller->ControllerNumber,
3984 LogicalDriveNumber,
3985 (100 * (BlocksCompleted >> 7))
3986 / (LogicalDriveSize >> 7));
3987 Controller->EphemeralProgressMessage = false;
3990 else if (CommandOpcode == DAC960_V1_BackgroundInitializationControl)
3992 unsigned int LogicalDriveNumber =
3993 Controller->V1.BackgroundInitializationStatus->LogicalDriveNumber;
3994 unsigned int LogicalDriveSize =
3995 Controller->V1.BackgroundInitializationStatus->LogicalDriveSize;
3996 unsigned int BlocksCompleted =
3997 Controller->V1.BackgroundInitializationStatus->BlocksCompleted;
3998 switch (CommandStatus)
4000 case DAC960_V1_NormalCompletion:
4001 switch (Controller->V1.BackgroundInitializationStatus->Status)
4003 case DAC960_V1_BackgroundInitializationInvalid:
4004 break;
4005 case DAC960_V1_BackgroundInitializationStarted:
4006 DAC960_Progress("Background Initialization Started\n",
4007 Controller);
4008 break;
4009 case DAC960_V1_BackgroundInitializationInProgress:
4010 if (BlocksCompleted ==
4011 Controller->V1.LastBackgroundInitializationStatus.
4012 BlocksCompleted &&
4013 LogicalDriveNumber ==
4014 Controller->V1.LastBackgroundInitializationStatus.
4015 LogicalDriveNumber)
4016 break;
4017 Controller->EphemeralProgressMessage = true;
4018 DAC960_Progress("Background Initialization in Progress: "
4019 "Logical Drive %d (/dev/rd/c%dd%d) "
4020 "%d%% completed\n",
4021 Controller, LogicalDriveNumber,
4022 Controller->ControllerNumber,
4023 LogicalDriveNumber,
4024 (100 * (BlocksCompleted >> 7))
4025 / (LogicalDriveSize >> 7));
4026 Controller->EphemeralProgressMessage = false;
4027 break;
4028 case DAC960_V1_BackgroundInitializationSuspended:
4029 DAC960_Progress("Background Initialization Suspended\n",
4030 Controller);
4031 break;
4032 case DAC960_V1_BackgroundInitializationCancelled:
4033 DAC960_Progress("Background Initialization Cancelled\n",
4034 Controller);
4035 break;
4037 memcpy(&Controller->V1.LastBackgroundInitializationStatus,
4038 Controller->V1.BackgroundInitializationStatus,
4039 sizeof(DAC960_V1_BackgroundInitializationStatus_T));
4040 break;
4041 case DAC960_V1_BackgroundInitSuccessful:
4042 if (Controller->V1.BackgroundInitializationStatus->Status ==
4043 DAC960_V1_BackgroundInitializationInProgress)
4044 DAC960_Progress("Background Initialization "
4045 "Completed Successfully\n", Controller);
4046 Controller->V1.BackgroundInitializationStatus->Status =
4047 DAC960_V1_BackgroundInitializationInvalid;
4048 break;
4049 case DAC960_V1_BackgroundInitAborted:
4050 if (Controller->V1.BackgroundInitializationStatus->Status ==
4051 DAC960_V1_BackgroundInitializationInProgress)
4052 DAC960_Progress("Background Initialization Aborted\n",
4053 Controller);
4054 Controller->V1.BackgroundInitializationStatus->Status =
4055 DAC960_V1_BackgroundInitializationInvalid;
4056 break;
4057 case DAC960_V1_NoBackgroundInitInProgress:
4058 break;
4061 else if (CommandOpcode == DAC960_V1_DCDB)
4063 /*
4064 This is a bit ugly.
4066 The InquiryStandardData and
4067 the InquiryUntitSerialNumber information
4068 retrieval operations BOTH use the DAC960_V1_DCDB
4069 commands. the test above can't distinguish between
4070 these two cases.
4072 Instead, we rely on the order of code later in this
4073 function to ensure that DeviceInquiryInformation commands
4074 are submitted before DeviceSerialNumber commands.
4075 */
4076 if (Controller->V1.NeedDeviceInquiryInformation)
4078 DAC960_SCSI_Inquiry_T *InquiryStandardData =
4079 &Controller->V1.InquiryStandardData
4080 [Controller->V1.DeviceStateChannel]
4081 [Controller->V1.DeviceStateTargetID];
4082 if (CommandStatus != DAC960_V1_NormalCompletion)
4084 memset(InquiryStandardData, 0,
4085 sizeof(DAC960_SCSI_Inquiry_T));
4086 InquiryStandardData->PeripheralDeviceType = 0x1F;
4088 else
4089 memcpy(InquiryStandardData,
4090 Controller->V1.NewInquiryStandardData,
4091 sizeof(DAC960_SCSI_Inquiry_T));
4092 Controller->V1.NeedDeviceInquiryInformation = false;
4094 else if (Controller->V1.NeedDeviceSerialNumberInformation)
4096 DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
4097 &Controller->V1.InquiryUnitSerialNumber
4098 [Controller->V1.DeviceStateChannel]
4099 [Controller->V1.DeviceStateTargetID];
4100 if (CommandStatus != DAC960_V1_NormalCompletion)
4102 memset(InquiryUnitSerialNumber, 0,
4103 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
4104 InquiryUnitSerialNumber->PeripheralDeviceType = 0x1F;
4106 else
4107 memcpy(InquiryUnitSerialNumber,
4108 Controller->V1.NewInquiryUnitSerialNumber,
4109 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
4110 Controller->V1.NeedDeviceSerialNumberInformation = false;
4113 /*
4114 Begin submitting new monitoring commands.
4115 */
4116 if (Controller->V1.NewEventLogSequenceNumber
4117 - Controller->V1.OldEventLogSequenceNumber > 0)
4119 Command->V1.CommandMailbox.Type3E.CommandOpcode =
4120 DAC960_V1_PerformEventLogOperation;
4121 Command->V1.CommandMailbox.Type3E.OperationType =
4122 DAC960_V1_GetEventLogEntry;
4123 Command->V1.CommandMailbox.Type3E.OperationQualifier = 1;
4124 Command->V1.CommandMailbox.Type3E.SequenceNumber =
4125 Controller->V1.OldEventLogSequenceNumber;
4126 Command->V1.CommandMailbox.Type3E.BusAddress =
4127 Controller->V1.EventLogEntryDMA;
4128 DAC960_QueueCommand(Command);
4129 return;
4131 if (Controller->V1.NeedErrorTableInformation)
4133 Controller->V1.NeedErrorTableInformation = false;
4134 Command->V1.CommandMailbox.Type3.CommandOpcode =
4135 DAC960_V1_GetErrorTable;
4136 Command->V1.CommandMailbox.Type3.BusAddress =
4137 Controller->V1.NewErrorTableDMA;
4138 DAC960_QueueCommand(Command);
4139 return;
4141 if (Controller->V1.NeedRebuildProgress &&
4142 Controller->V1.RebuildProgressFirst)
4144 Controller->V1.NeedRebuildProgress = false;
4145 Command->V1.CommandMailbox.Type3.CommandOpcode =
4146 DAC960_V1_GetRebuildProgress;
4147 Command->V1.CommandMailbox.Type3.BusAddress =
4148 Controller->V1.RebuildProgressDMA;
4149 DAC960_QueueCommand(Command);
4150 return;
4152 if (Controller->V1.NeedDeviceStateInformation)
4154 if (Controller->V1.NeedDeviceInquiryInformation)
4156 DAC960_V1_DCDB_T *DCDB = Controller->V1.MonitoringDCDB;
4157 dma_addr_t DCDB_DMA = Controller->V1.MonitoringDCDB_DMA;
4159 dma_addr_t NewInquiryStandardDataDMA =
4160 Controller->V1.NewInquiryStandardDataDMA;
4162 Command->V1.CommandMailbox.Type3.CommandOpcode = DAC960_V1_DCDB;
4163 Command->V1.CommandMailbox.Type3.BusAddress = DCDB_DMA;
4164 DCDB->Channel = Controller->V1.DeviceStateChannel;
4165 DCDB->TargetID = Controller->V1.DeviceStateTargetID;
4166 DCDB->Direction = DAC960_V1_DCDB_DataTransferDeviceToSystem;
4167 DCDB->EarlyStatus = false;
4168 DCDB->Timeout = DAC960_V1_DCDB_Timeout_10_seconds;
4169 DCDB->NoAutomaticRequestSense = false;
4170 DCDB->DisconnectPermitted = true;
4171 DCDB->TransferLength = sizeof(DAC960_SCSI_Inquiry_T);
4172 DCDB->BusAddress = NewInquiryStandardDataDMA;
4173 DCDB->CDBLength = 6;
4174 DCDB->TransferLengthHigh4 = 0;
4175 DCDB->SenseLength = sizeof(DCDB->SenseData);
4176 DCDB->CDB[0] = 0x12; /* INQUIRY */
4177 DCDB->CDB[1] = 0; /* EVPD = 0 */
4178 DCDB->CDB[2] = 0; /* Page Code */
4179 DCDB->CDB[3] = 0; /* Reserved */
4180 DCDB->CDB[4] = sizeof(DAC960_SCSI_Inquiry_T);
4181 DCDB->CDB[5] = 0; /* Control */
4182 DAC960_QueueCommand(Command);
4183 return;
4185 if (Controller->V1.NeedDeviceSerialNumberInformation)
4187 DAC960_V1_DCDB_T *DCDB = Controller->V1.MonitoringDCDB;
4188 dma_addr_t DCDB_DMA = Controller->V1.MonitoringDCDB_DMA;
4189 dma_addr_t NewInquiryUnitSerialNumberDMA =
4190 Controller->V1.NewInquiryUnitSerialNumberDMA;
4192 Command->V1.CommandMailbox.Type3.CommandOpcode = DAC960_V1_DCDB;
4193 Command->V1.CommandMailbox.Type3.BusAddress = DCDB_DMA;
4194 DCDB->Channel = Controller->V1.DeviceStateChannel;
4195 DCDB->TargetID = Controller->V1.DeviceStateTargetID;
4196 DCDB->Direction = DAC960_V1_DCDB_DataTransferDeviceToSystem;
4197 DCDB->EarlyStatus = false;
4198 DCDB->Timeout = DAC960_V1_DCDB_Timeout_10_seconds;
4199 DCDB->NoAutomaticRequestSense = false;
4200 DCDB->DisconnectPermitted = true;
4201 DCDB->TransferLength =
4202 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T);
4203 DCDB->BusAddress = NewInquiryUnitSerialNumberDMA;
4204 DCDB->CDBLength = 6;
4205 DCDB->TransferLengthHigh4 = 0;
4206 DCDB->SenseLength = sizeof(DCDB->SenseData);
4207 DCDB->CDB[0] = 0x12; /* INQUIRY */
4208 DCDB->CDB[1] = 1; /* EVPD = 1 */
4209 DCDB->CDB[2] = 0x80; /* Page Code */
4210 DCDB->CDB[3] = 0; /* Reserved */
4211 DCDB->CDB[4] = sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T);
4212 DCDB->CDB[5] = 0; /* Control */
4213 DAC960_QueueCommand(Command);
4214 return;
4216 if (Controller->V1.StartDeviceStateScan)
4218 Controller->V1.DeviceStateChannel = 0;
4219 Controller->V1.DeviceStateTargetID = 0;
4220 Controller->V1.StartDeviceStateScan = false;
4222 else if (++Controller->V1.DeviceStateTargetID == Controller->Targets)
4224 Controller->V1.DeviceStateChannel++;
4225 Controller->V1.DeviceStateTargetID = 0;
4227 if (Controller->V1.DeviceStateChannel < Controller->Channels)
4229 Controller->V1.NewDeviceState->DeviceState =
4230 DAC960_V1_Device_Dead;
4231 Command->V1.CommandMailbox.Type3D.CommandOpcode =
4232 DAC960_V1_GetDeviceState;
4233 Command->V1.CommandMailbox.Type3D.Channel =
4234 Controller->V1.DeviceStateChannel;
4235 Command->V1.CommandMailbox.Type3D.TargetID =
4236 Controller->V1.DeviceStateTargetID;
4237 Command->V1.CommandMailbox.Type3D.BusAddress =
4238 Controller->V1.NewDeviceStateDMA;
4239 DAC960_QueueCommand(Command);
4240 return;
4242 Controller->V1.NeedDeviceStateInformation = false;
4244 if (Controller->V1.NeedLogicalDriveInformation)
4246 Controller->V1.NeedLogicalDriveInformation = false;
4247 Command->V1.CommandMailbox.Type3.CommandOpcode =
4248 DAC960_V1_GetLogicalDriveInformation;
4249 Command->V1.CommandMailbox.Type3.BusAddress =
4250 Controller->V1.NewLogicalDriveInformationDMA;
4251 DAC960_QueueCommand(Command);
4252 return;
4254 if (Controller->V1.NeedRebuildProgress)
4256 Controller->V1.NeedRebuildProgress = false;
4257 Command->V1.CommandMailbox.Type3.CommandOpcode =
4258 DAC960_V1_GetRebuildProgress;
4259 Command->V1.CommandMailbox.Type3.BusAddress =
4260 Controller->V1.RebuildProgressDMA;
4261 DAC960_QueueCommand(Command);
4262 return;
4264 if (Controller->V1.NeedConsistencyCheckProgress)
4266 Controller->V1.NeedConsistencyCheckProgress = false;
4267 Command->V1.CommandMailbox.Type3.CommandOpcode =
4268 DAC960_V1_RebuildStat;
4269 Command->V1.CommandMailbox.Type3.BusAddress =
4270 Controller->V1.RebuildProgressDMA;
4271 DAC960_QueueCommand(Command);
4272 return;
4274 if (Controller->V1.NeedBackgroundInitializationStatus)
4276 Controller->V1.NeedBackgroundInitializationStatus = false;
4277 Command->V1.CommandMailbox.Type3B.CommandOpcode =
4278 DAC960_V1_BackgroundInitializationControl;
4279 Command->V1.CommandMailbox.Type3B.CommandOpcode2 = 0x20;
4280 Command->V1.CommandMailbox.Type3B.BusAddress =
4281 Controller->V1.BackgroundInitializationStatusDMA;
4282 DAC960_QueueCommand(Command);
4283 return;
4285 Controller->MonitoringTimerCount++;
4286 Controller->MonitoringTimer.expires =
4287 jiffies + DAC960_MonitoringTimerInterval;
4288 add_timer(&Controller->MonitoringTimer);
4290 if (CommandType == DAC960_ImmediateCommand)
4292 complete(Command->Completion);
4293 Command->Completion = NULL;
4294 return;
4296 if (CommandType == DAC960_QueuedCommand)
4298 DAC960_V1_KernelCommand_T *KernelCommand = Command->V1.KernelCommand;
4299 KernelCommand->CommandStatus = Command->V1.CommandStatus;
4300 Command->V1.KernelCommand = NULL;
4301 if (CommandOpcode == DAC960_V1_DCDB)
4302 Controller->V1.DirectCommandActive[KernelCommand->DCDB->Channel]
4303 [KernelCommand->DCDB->TargetID] =
4304 false;
4305 DAC960_DeallocateCommand(Command);
4306 KernelCommand->CompletionFunction(KernelCommand);
4307 return;
4309 /*
4310 Queue a Status Monitoring Command to the Controller using the just
4311 completed Command if one was deferred previously due to lack of a
4312 free Command when the Monitoring Timer Function was called.
4313 */
4314 if (Controller->MonitoringCommandDeferred)
4316 Controller->MonitoringCommandDeferred = false;
4317 DAC960_V1_QueueMonitoringCommand(Command);
4318 return;
4320 /*
4321 Deallocate the Command.
4322 */
4323 DAC960_DeallocateCommand(Command);
4324 /*
4325 Wake up any processes waiting on a free Command.
4326 */
4327 wake_up(&Controller->CommandWaitQueue);
4331 /*
4332 DAC960_V2_ReadWriteError prints an appropriate error message for Command
4333 when an error occurs on a Read or Write operation.
4334 */
4336 static void DAC960_V2_ReadWriteError(DAC960_Command_T *Command)
4338 DAC960_Controller_T *Controller = Command->Controller;
4339 unsigned char *SenseErrors[] = { "NO SENSE", "RECOVERED ERROR",
4340 "NOT READY", "MEDIUM ERROR",
4341 "HARDWARE ERROR", "ILLEGAL REQUEST",
4342 "UNIT ATTENTION", "DATA PROTECT",
4343 "BLANK CHECK", "VENDOR-SPECIFIC",
4344 "COPY ABORTED", "ABORTED COMMAND",
4345 "EQUAL", "VOLUME OVERFLOW",
4346 "MISCOMPARE", "RESERVED" };
4347 unsigned char *CommandName = "UNKNOWN";
4348 switch (Command->CommandType)
4350 case DAC960_ReadCommand:
4351 case DAC960_ReadRetryCommand:
4352 CommandName = "READ";
4353 break;
4354 case DAC960_WriteCommand:
4355 case DAC960_WriteRetryCommand:
4356 CommandName = "WRITE";
4357 break;
4358 case DAC960_MonitoringCommand:
4359 case DAC960_ImmediateCommand:
4360 case DAC960_QueuedCommand:
4361 break;
4363 DAC960_Error("Error Condition %s on %s:\n", Controller,
4364 SenseErrors[Command->V2.RequestSense->SenseKey], CommandName);
4365 DAC960_Error(" /dev/rd/c%dd%d: absolute blocks %u..%u\n",
4366 Controller, Controller->ControllerNumber,
4367 Command->LogicalDriveNumber, Command->BlockNumber,
4368 Command->BlockNumber + Command->BlockCount - 1);
4372 /*
4373 DAC960_V2_ReportEvent prints an appropriate message when a Controller Event
4374 occurs.
4375 */
4377 static void DAC960_V2_ReportEvent(DAC960_Controller_T *Controller,
4378 DAC960_V2_Event_T *Event)
4380 DAC960_SCSI_RequestSense_T *RequestSense =
4381 (DAC960_SCSI_RequestSense_T *) &Event->RequestSenseData;
4382 unsigned char MessageBuffer[DAC960_LineBufferSize];
4383 static struct { int EventCode; unsigned char *EventMessage; } EventList[] =
4384 { /* Physical Device Events (0x0000 - 0x007F) */
4385 { 0x0001, "P Online" },
4386 { 0x0002, "P Standby" },
4387 { 0x0005, "P Automatic Rebuild Started" },
4388 { 0x0006, "P Manual Rebuild Started" },
4389 { 0x0007, "P Rebuild Completed" },
4390 { 0x0008, "P Rebuild Cancelled" },
4391 { 0x0009, "P Rebuild Failed for Unknown Reasons" },
4392 { 0x000A, "P Rebuild Failed due to New Physical Device" },
4393 { 0x000B, "P Rebuild Failed due to Logical Drive Failure" },
4394 { 0x000C, "S Offline" },
4395 { 0x000D, "P Found" },
4396 { 0x000E, "P Removed" },
4397 { 0x000F, "P Unconfigured" },
4398 { 0x0010, "P Expand Capacity Started" },
4399 { 0x0011, "P Expand Capacity Completed" },
4400 { 0x0012, "P Expand Capacity Failed" },
4401 { 0x0013, "P Command Timed Out" },
4402 { 0x0014, "P Command Aborted" },
4403 { 0x0015, "P Command Retried" },
4404 { 0x0016, "P Parity Error" },
4405 { 0x0017, "P Soft Error" },
4406 { 0x0018, "P Miscellaneous Error" },
4407 { 0x0019, "P Reset" },
4408 { 0x001A, "P Active Spare Found" },
4409 { 0x001B, "P Warm Spare Found" },
4410 { 0x001C, "S Sense Data Received" },
4411 { 0x001D, "P Initialization Started" },
4412 { 0x001E, "P Initialization Completed" },
4413 { 0x001F, "P Initialization Failed" },
4414 { 0x0020, "P Initialization Cancelled" },
4415 { 0x0021, "P Failed because Write Recovery Failed" },
4416 { 0x0022, "P Failed because SCSI Bus Reset Failed" },
4417 { 0x0023, "P Failed because of Double Check Condition" },
4418 { 0x0024, "P Failed because Device Cannot Be Accessed" },
4419 { 0x0025, "P Failed because of Gross Error on SCSI Processor" },
4420 { 0x0026, "P Failed because of Bad Tag from Device" },
4421 { 0x0027, "P Failed because of Command Timeout" },
4422 { 0x0028, "P Failed because of System Reset" },
4423 { 0x0029, "P Failed because of Busy Status or Parity Error" },
4424 { 0x002A, "P Failed because Host Set Device to Failed State" },
4425 { 0x002B, "P Failed because of Selection Timeout" },
4426 { 0x002C, "P Failed because of SCSI Bus Phase Error" },
4427 { 0x002D, "P Failed because Device Returned Unknown Status" },
4428 { 0x002E, "P Failed because Device Not Ready" },
4429 { 0x002F, "P Failed because Device Not Found at Startup" },
4430 { 0x0030, "P Failed because COD Write Operation Failed" },
4431 { 0x0031, "P Failed because BDT Write Operation Failed" },
4432 { 0x0039, "P Missing at Startup" },
4433 { 0x003A, "P Start Rebuild Failed due to Physical Drive Too Small" },
4434 { 0x003C, "P Temporarily Offline Device Automatically Made Online" },
4435 { 0x003D, "P Standby Rebuild Started" },
4436 /* Logical Device Events (0x0080 - 0x00FF) */
4437 { 0x0080, "M Consistency Check Started" },
4438 { 0x0081, "M Consistency Check Completed" },
4439 { 0x0082, "M Consistency Check Cancelled" },
4440 { 0x0083, "M Consistency Check Completed With Errors" },
4441 { 0x0084, "M Consistency Check Failed due to Logical Drive Failure" },
4442 { 0x0085, "M Consistency Check Failed due to Physical Device Failure" },
4443 { 0x0086, "L Offline" },
4444 { 0x0087, "L Critical" },
4445 { 0x0088, "L Online" },
4446 { 0x0089, "M Automatic Rebuild Started" },
4447 { 0x008A, "M Manual Rebuild Started" },
4448 { 0x008B, "M Rebuild Completed" },
4449 { 0x008C, "M Rebuild Cancelled" },
4450 { 0x008D, "M Rebuild Failed for Unknown Reasons" },
4451 { 0x008E, "M Rebuild Failed due to New Physical Device" },
4452 { 0x008F, "M Rebuild Failed due to Logical Drive Failure" },
4453 { 0x0090, "M Initialization Started" },
4454 { 0x0091, "M Initialization Completed" },
4455 { 0x0092, "M Initialization Cancelled" },
4456 { 0x0093, "M Initialization Failed" },
4457 { 0x0094, "L Found" },
4458 { 0x0095, "L Deleted" },
4459 { 0x0096, "M Expand Capacity Started" },
4460 { 0x0097, "M Expand Capacity Completed" },
4461 { 0x0098, "M Expand Capacity Failed" },
4462 { 0x0099, "L Bad Block Found" },
4463 { 0x009A, "L Size Changed" },
4464 { 0x009B, "L Type Changed" },
4465 { 0x009C, "L Bad Data Block Found" },
4466 { 0x009E, "L Read of Data Block in BDT" },
4467 { 0x009F, "L Write Back Data for Disk Block Lost" },
4468 { 0x00A0, "L Temporarily Offline RAID-5/3 Drive Made Online" },
4469 { 0x00A1, "L Temporarily Offline RAID-6/1/0/7 Drive Made Online" },
4470 { 0x00A2, "L Standby Rebuild Started" },
4471 /* Fault Management Events (0x0100 - 0x017F) */
4472 { 0x0140, "E Fan %d Failed" },
4473 { 0x0141, "E Fan %d OK" },
4474 { 0x0142, "E Fan %d Not Present" },
4475 { 0x0143, "E Power Supply %d Failed" },
4476 { 0x0144, "E Power Supply %d OK" },
4477 { 0x0145, "E Power Supply %d Not Present" },
4478 { 0x0146, "E Temperature Sensor %d Temperature Exceeds Safe Limit" },
4479 { 0x0147, "E Temperature Sensor %d Temperature Exceeds Working Limit" },
4480 { 0x0148, "E Temperature Sensor %d Temperature Normal" },
4481 { 0x0149, "E Temperature Sensor %d Not Present" },
4482 { 0x014A, "E Enclosure Management Unit %d Access Critical" },
4483 { 0x014B, "E Enclosure Management Unit %d Access OK" },
4484 { 0x014C, "E Enclosure Management Unit %d Access Offline" },
4485 /* Controller Events (0x0180 - 0x01FF) */
4486 { 0x0181, "C Cache Write Back Error" },
4487 { 0x0188, "C Battery Backup Unit Found" },
4488 { 0x0189, "C Battery Backup Unit Charge Level Low" },
4489 { 0x018A, "C Battery Backup Unit Charge Level OK" },
4490 { 0x0193, "C Installation Aborted" },
4491 { 0x0195, "C Battery Backup Unit Physically Removed" },
4492 { 0x0196, "C Memory Error During Warm Boot" },
4493 { 0x019E, "C Memory Soft ECC Error Corrected" },
4494 { 0x019F, "C Memory Hard ECC Error Corrected" },
4495 { 0x01A2, "C Battery Backup Unit Failed" },
4496 { 0x01AB, "C Mirror Race Recovery Failed" },
4497 { 0x01AC, "C Mirror Race on Critical Drive" },
4498 /* Controller Internal Processor Events */
4499 { 0x0380, "C Internal Controller Hung" },
4500 { 0x0381, "C Internal Controller Firmware Breakpoint" },
4501 { 0x0390, "C Internal Controller i960 Processor Specific Error" },
4502 { 0x03A0, "C Internal Controller StrongARM Processor Specific Error" },
4503 { 0, "" } };
4504 int EventListIndex = 0, EventCode;
4505 unsigned char EventType, *EventMessage;
4506 if (Event->EventCode == 0x1C &&
4507 RequestSense->SenseKey == DAC960_SenseKey_VendorSpecific &&
4508 (RequestSense->AdditionalSenseCode == 0x80 ||
4509 RequestSense->AdditionalSenseCode == 0x81))
4510 Event->EventCode = ((RequestSense->AdditionalSenseCode - 0x80) << 8) |
4511 RequestSense->AdditionalSenseCodeQualifier;
4512 while (true)
4514 EventCode = EventList[EventListIndex].EventCode;
4515 if (EventCode == Event->EventCode || EventCode == 0) break;
4516 EventListIndex++;
4518 EventType = EventList[EventListIndex].EventMessage[0];
4519 EventMessage = &EventList[EventListIndex].EventMessage[2];
4520 if (EventCode == 0)
4522 DAC960_Critical("Unknown Controller Event Code %04X\n",
4523 Controller, Event->EventCode);
4524 return;
4526 switch (EventType)
4528 case 'P':
4529 DAC960_Critical("Physical Device %d:%d %s\n", Controller,
4530 Event->Channel, Event->TargetID, EventMessage);
4531 break;
4532 case 'L':
4533 DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) %s\n", Controller,
4534 Event->LogicalUnit, Controller->ControllerNumber,
4535 Event->LogicalUnit, EventMessage);
4536 break;
4537 case 'M':
4538 DAC960_Progress("Logical Drive %d (/dev/rd/c%dd%d) %s\n", Controller,
4539 Event->LogicalUnit, Controller->ControllerNumber,
4540 Event->LogicalUnit, EventMessage);
4541 break;
4542 case 'S':
4543 if (RequestSense->SenseKey == DAC960_SenseKey_NoSense ||
4544 (RequestSense->SenseKey == DAC960_SenseKey_NotReady &&
4545 RequestSense->AdditionalSenseCode == 0x04 &&
4546 (RequestSense->AdditionalSenseCodeQualifier == 0x01 ||
4547 RequestSense->AdditionalSenseCodeQualifier == 0x02)))
4548 break;
4549 DAC960_Critical("Physical Device %d:%d %s\n", Controller,
4550 Event->Channel, Event->TargetID, EventMessage);
4551 DAC960_Critical("Physical Device %d:%d Request Sense: "
4552 "Sense Key = %X, ASC = %02X, ASCQ = %02X\n",
4553 Controller,
4554 Event->Channel,
4555 Event->TargetID,
4556 RequestSense->SenseKey,
4557 RequestSense->AdditionalSenseCode,
4558 RequestSense->AdditionalSenseCodeQualifier);
4559 DAC960_Critical("Physical Device %d:%d Request Sense: "
4560 "Information = %02X%02X%02X%02X "
4561 "%02X%02X%02X%02X\n",
4562 Controller,
4563 Event->Channel,
4564 Event->TargetID,
4565 RequestSense->Information[0],
4566 RequestSense->Information[1],
4567 RequestSense->Information[2],
4568 RequestSense->Information[3],
4569 RequestSense->CommandSpecificInformation[0],
4570 RequestSense->CommandSpecificInformation[1],
4571 RequestSense->CommandSpecificInformation[2],
4572 RequestSense->CommandSpecificInformation[3]);
4573 break;
4574 case 'E':
4575 if (Controller->SuppressEnclosureMessages) break;
4576 sprintf(MessageBuffer, EventMessage, Event->LogicalUnit);
4577 DAC960_Critical("Enclosure %d %s\n", Controller,
4578 Event->TargetID, MessageBuffer);
4579 break;
4580 case 'C':
4581 DAC960_Critical("Controller %s\n", Controller, EventMessage);
4582 break;
4583 default:
4584 DAC960_Critical("Unknown Controller Event Code %04X\n",
4585 Controller, Event->EventCode);
4586 break;
4591 /*
4592 DAC960_V2_ReportProgress prints an appropriate progress message for
4593 Logical Device Long Operations.
4594 */
4596 static void DAC960_V2_ReportProgress(DAC960_Controller_T *Controller,
4597 unsigned char *MessageString,
4598 unsigned int LogicalDeviceNumber,
4599 unsigned long BlocksCompleted,
4600 unsigned long LogicalDeviceSize)
4602 Controller->EphemeralProgressMessage = true;
4603 DAC960_Progress("%s in Progress: Logical Drive %d (/dev/rd/c%dd%d) "
4604 "%d%% completed\n", Controller,
4605 MessageString,
4606 LogicalDeviceNumber,
4607 Controller->ControllerNumber,
4608 LogicalDeviceNumber,
4609 (100 * (BlocksCompleted >> 7)) / (LogicalDeviceSize >> 7));
4610 Controller->EphemeralProgressMessage = false;
4614 /*
4615 DAC960_V2_ProcessCompletedCommand performs completion processing for Command
4616 for DAC960 V2 Firmware Controllers.
4617 */
4619 static void DAC960_V2_ProcessCompletedCommand(DAC960_Command_T *Command)
4621 DAC960_Controller_T *Controller = Command->Controller;
4622 DAC960_CommandType_T CommandType = Command->CommandType;
4623 DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
4624 DAC960_V2_IOCTL_Opcode_T CommandOpcode = CommandMailbox->Common.IOCTL_Opcode;
4625 DAC960_V2_CommandStatus_T CommandStatus = Command->V2.CommandStatus;
4627 if (CommandType == DAC960_ReadCommand ||
4628 CommandType == DAC960_WriteCommand)
4631 #ifdef FORCE_RETRY_DEBUG
4632 CommandStatus = DAC960_V2_AbormalCompletion;
4633 #endif
4634 Command->V2.RequestSense->SenseKey = DAC960_SenseKey_MediumError;
4636 if (CommandStatus == DAC960_V2_NormalCompletion) {
4638 if (!DAC960_ProcessCompletedRequest(Command, true))
4639 BUG();
4641 } else if (Command->V2.RequestSense->SenseKey == DAC960_SenseKey_MediumError)
4643 /*
4644 * break the command down into pieces and resubmit each
4645 * piece, hoping that some of them will succeed.
4646 */
4647 DAC960_queue_partial_rw(Command);
4648 return;
4650 else
4652 if (Command->V2.RequestSense->SenseKey != DAC960_SenseKey_NotReady)
4653 DAC960_V2_ReadWriteError(Command);
4654 /*
4655 Perform completion processing for all buffers in this I/O Request.
4656 */
4657 (void)DAC960_ProcessCompletedRequest(Command, false);
4660 else if (CommandType == DAC960_ReadRetryCommand ||
4661 CommandType == DAC960_WriteRetryCommand)
4663 boolean normal_completion;
4665 #ifdef FORCE_RETRY_FAILURE_DEBUG
4666 static int retry_count = 1;
4667 #endif
4668 /*
4669 Perform completion processing for the portion that was
4670 retried, and submit the next portion, if any.
4671 */
4672 normal_completion = true;
4673 if (CommandStatus != DAC960_V2_NormalCompletion) {
4674 normal_completion = false;
4675 if (Command->V2.RequestSense->SenseKey != DAC960_SenseKey_NotReady)
4676 DAC960_V2_ReadWriteError(Command);
4679 #ifdef FORCE_RETRY_FAILURE_DEBUG
4680 if (!(++retry_count % 10000)) {
4681 printk("V2 error retry failure test\n");
4682 normal_completion = false;
4683 DAC960_V2_ReadWriteError(Command);
4685 #endif
4687 if (!DAC960_ProcessCompletedRequest(Command, normal_completion)) {
4688 DAC960_queue_partial_rw(Command);
4689 return;
4692 else if (CommandType == DAC960_MonitoringCommand)
4694 if (Controller->ShutdownMonitoringTimer)
4695 return;
4696 if (CommandOpcode == DAC960_V2_GetControllerInfo)
4698 DAC960_V2_ControllerInfo_T *NewControllerInfo =
4699 Controller->V2.NewControllerInformation;
4700 DAC960_V2_ControllerInfo_T *ControllerInfo =
4701 &Controller->V2.ControllerInformation;
4702 Controller->LogicalDriveCount =
4703 NewControllerInfo->LogicalDevicesPresent;
4704 Controller->V2.NeedLogicalDeviceInformation = true;
4705 Controller->V2.NeedPhysicalDeviceInformation = true;
4706 Controller->V2.StartLogicalDeviceInformationScan = true;
4707 Controller->V2.StartPhysicalDeviceInformationScan = true;
4708 Controller->MonitoringAlertMode =
4709 (NewControllerInfo->LogicalDevicesCritical > 0 ||
4710 NewControllerInfo->LogicalDevicesOffline > 0 ||
4711 NewControllerInfo->PhysicalDisksCritical > 0 ||
4712 NewControllerInfo->PhysicalDisksOffline > 0);
4713 memcpy(ControllerInfo, NewControllerInfo,
4714 sizeof(DAC960_V2_ControllerInfo_T));
4716 else if (CommandOpcode == DAC960_V2_GetEvent)
4718 if (CommandStatus == DAC960_V2_NormalCompletion) {
4719 DAC960_V2_ReportEvent(Controller, Controller->V2.Event);
4721 Controller->V2.NextEventSequenceNumber++;
4723 else if (CommandOpcode == DAC960_V2_GetPhysicalDeviceInfoValid &&
4724 CommandStatus == DAC960_V2_NormalCompletion)
4726 DAC960_V2_PhysicalDeviceInfo_T *NewPhysicalDeviceInfo =
4727 Controller->V2.NewPhysicalDeviceInformation;
4728 unsigned int PhysicalDeviceIndex = Controller->V2.PhysicalDeviceIndex;
4729 DAC960_V2_PhysicalDeviceInfo_T *PhysicalDeviceInfo =
4730 Controller->V2.PhysicalDeviceInformation[PhysicalDeviceIndex];
4731 DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
4732 Controller->V2.InquiryUnitSerialNumber[PhysicalDeviceIndex];
4733 unsigned int DeviceIndex;
4734 while (PhysicalDeviceInfo != NULL &&
4735 (NewPhysicalDeviceInfo->Channel >
4736 PhysicalDeviceInfo->Channel ||
4737 (NewPhysicalDeviceInfo->Channel ==
4738 PhysicalDeviceInfo->Channel &&
4739 (NewPhysicalDeviceInfo->TargetID >
4740 PhysicalDeviceInfo->TargetID ||
4741 (NewPhysicalDeviceInfo->TargetID ==
4742 PhysicalDeviceInfo->TargetID &&
4743 NewPhysicalDeviceInfo->LogicalUnit >
4744 PhysicalDeviceInfo->LogicalUnit)))))
4746 DAC960_Critical("Physical Device %d:%d No Longer Exists\n",
4747 Controller,
4748 PhysicalDeviceInfo->Channel,
4749 PhysicalDeviceInfo->TargetID);
4750 Controller->V2.PhysicalDeviceInformation
4751 [PhysicalDeviceIndex] = NULL;
4752 Controller->V2.InquiryUnitSerialNumber
4753 [PhysicalDeviceIndex] = NULL;
4754 kfree(PhysicalDeviceInfo);
4755 kfree(InquiryUnitSerialNumber);
4756 for (DeviceIndex = PhysicalDeviceIndex;
4757 DeviceIndex < DAC960_V2_MaxPhysicalDevices - 1;
4758 DeviceIndex++)
4760 Controller->V2.PhysicalDeviceInformation[DeviceIndex] =
4761 Controller->V2.PhysicalDeviceInformation[DeviceIndex+1];
4762 Controller->V2.InquiryUnitSerialNumber[DeviceIndex] =
4763 Controller->V2.InquiryUnitSerialNumber[DeviceIndex+1];
4765 Controller->V2.PhysicalDeviceInformation
4766 [DAC960_V2_MaxPhysicalDevices-1] = NULL;
4767 Controller->V2.InquiryUnitSerialNumber
4768 [DAC960_V2_MaxPhysicalDevices-1] = NULL;
4769 PhysicalDeviceInfo =
4770 Controller->V2.PhysicalDeviceInformation[PhysicalDeviceIndex];
4771 InquiryUnitSerialNumber =
4772 Controller->V2.InquiryUnitSerialNumber[PhysicalDeviceIndex];
4774 if (PhysicalDeviceInfo == NULL ||
4775 (NewPhysicalDeviceInfo->Channel !=
4776 PhysicalDeviceInfo->Channel) ||
4777 (NewPhysicalDeviceInfo->TargetID !=
4778 PhysicalDeviceInfo->TargetID) ||
4779 (NewPhysicalDeviceInfo->LogicalUnit !=
4780 PhysicalDeviceInfo->LogicalUnit))
4782 PhysicalDeviceInfo =
4783 kmalloc(sizeof(DAC960_V2_PhysicalDeviceInfo_T), GFP_ATOMIC);
4784 InquiryUnitSerialNumber =
4785 kmalloc(sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T),
4786 GFP_ATOMIC);
4787 if (InquiryUnitSerialNumber == NULL ||
4788 PhysicalDeviceInfo == NULL)
4790 kfree(InquiryUnitSerialNumber);
4791 InquiryUnitSerialNumber = NULL;
4792 kfree(PhysicalDeviceInfo);
4793 PhysicalDeviceInfo = NULL;
4795 DAC960_Critical("Physical Device %d:%d Now Exists%s\n",
4796 Controller,
4797 NewPhysicalDeviceInfo->Channel,
4798 NewPhysicalDeviceInfo->TargetID,
4799 (PhysicalDeviceInfo != NULL
4800 ? "" : " - Allocation Failed"));
4801 if (PhysicalDeviceInfo != NULL)
4803 memset(PhysicalDeviceInfo, 0,
4804 sizeof(DAC960_V2_PhysicalDeviceInfo_T));
4805 PhysicalDeviceInfo->PhysicalDeviceState =
4806 DAC960_V2_Device_InvalidState;
4807 memset(InquiryUnitSerialNumber, 0,
4808 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
4809 InquiryUnitSerialNumber->PeripheralDeviceType = 0x1F;
4810 for (DeviceIndex = DAC960_V2_MaxPhysicalDevices - 1;
4811 DeviceIndex > PhysicalDeviceIndex;
4812 DeviceIndex--)
4814 Controller->V2.PhysicalDeviceInformation[DeviceIndex] =
4815 Controller->V2.PhysicalDeviceInformation[DeviceIndex-1];
4816 Controller->V2.InquiryUnitSerialNumber[DeviceIndex] =
4817 Controller->V2.InquiryUnitSerialNumber[DeviceIndex-1];
4819 Controller->V2.PhysicalDeviceInformation
4820 [PhysicalDeviceIndex] =
4821 PhysicalDeviceInfo;
4822 Controller->V2.InquiryUnitSerialNumber
4823 [PhysicalDeviceIndex] =
4824 InquiryUnitSerialNumber;
4825 Controller->V2.NeedDeviceSerialNumberInformation = true;
4828 if (PhysicalDeviceInfo != NULL)
4830 if (NewPhysicalDeviceInfo->PhysicalDeviceState !=
4831 PhysicalDeviceInfo->PhysicalDeviceState)
4832 DAC960_Critical(
4833 "Physical Device %d:%d is now %s\n", Controller,
4834 NewPhysicalDeviceInfo->Channel,
4835 NewPhysicalDeviceInfo->TargetID,
4836 (NewPhysicalDeviceInfo->PhysicalDeviceState
4837 == DAC960_V2_Device_Online
4838 ? "ONLINE"
4839 : NewPhysicalDeviceInfo->PhysicalDeviceState
4840 == DAC960_V2_Device_Rebuild
4841 ? "REBUILD"
4842 : NewPhysicalDeviceInfo->PhysicalDeviceState
4843 == DAC960_V2_Device_Missing
4844 ? "MISSING"
4845 : NewPhysicalDeviceInfo->PhysicalDeviceState
4846 == DAC960_V2_Device_Critical
4847 ? "CRITICAL"
4848 : NewPhysicalDeviceInfo->PhysicalDeviceState
4849 == DAC960_V2_Device_Dead
4850 ? "DEAD"
4851 : NewPhysicalDeviceInfo->PhysicalDeviceState
4852 == DAC960_V2_Device_SuspectedDead
4853 ? "SUSPECTED-DEAD"
4854 : NewPhysicalDeviceInfo->PhysicalDeviceState
4855 == DAC960_V2_Device_CommandedOffline
4856 ? "COMMANDED-OFFLINE"
4857 : NewPhysicalDeviceInfo->PhysicalDeviceState
4858 == DAC960_V2_Device_Standby
4859 ? "STANDBY" : "UNKNOWN"));
4860 if ((NewPhysicalDeviceInfo->ParityErrors !=
4861 PhysicalDeviceInfo->ParityErrors) ||
4862 (NewPhysicalDeviceInfo->SoftErrors !=
4863 PhysicalDeviceInfo->SoftErrors) ||
4864 (NewPhysicalDeviceInfo->HardErrors !=
4865 PhysicalDeviceInfo->HardErrors) ||
4866 (NewPhysicalDeviceInfo->MiscellaneousErrors !=
4867 PhysicalDeviceInfo->MiscellaneousErrors) ||
4868 (NewPhysicalDeviceInfo->CommandTimeouts !=
4869 PhysicalDeviceInfo->CommandTimeouts) ||
4870 (NewPhysicalDeviceInfo->Retries !=
4871 PhysicalDeviceInfo->Retries) ||
4872 (NewPhysicalDeviceInfo->Aborts !=
4873 PhysicalDeviceInfo->Aborts) ||
4874 (NewPhysicalDeviceInfo->PredictedFailuresDetected !=
4875 PhysicalDeviceInfo->PredictedFailuresDetected))
4877 DAC960_Critical("Physical Device %d:%d Errors: "
4878 "Parity = %d, Soft = %d, "
4879 "Hard = %d, Misc = %d\n",
4880 Controller,
4881 NewPhysicalDeviceInfo->Channel,
4882 NewPhysicalDeviceInfo->TargetID,
4883 NewPhysicalDeviceInfo->ParityErrors,
4884 NewPhysicalDeviceInfo->SoftErrors,
4885 NewPhysicalDeviceInfo->HardErrors,
4886 NewPhysicalDeviceInfo->MiscellaneousErrors);
4887 DAC960_Critical("Physical Device %d:%d Errors: "
4888 "Timeouts = %d, Retries = %d, "
4889 "Aborts = %d, Predicted = %d\n",
4890 Controller,
4891 NewPhysicalDeviceInfo->Channel,
4892 NewPhysicalDeviceInfo->TargetID,
4893 NewPhysicalDeviceInfo->CommandTimeouts,
4894 NewPhysicalDeviceInfo->Retries,
4895 NewPhysicalDeviceInfo->Aborts,
4896 NewPhysicalDeviceInfo
4897 ->PredictedFailuresDetected);
4899 if ((PhysicalDeviceInfo->PhysicalDeviceState
4900 == DAC960_V2_Device_Dead ||
4901 PhysicalDeviceInfo->PhysicalDeviceState
4902 == DAC960_V2_Device_InvalidState) &&
4903 NewPhysicalDeviceInfo->PhysicalDeviceState
4904 != DAC960_V2_Device_Dead)
4905 Controller->V2.NeedDeviceSerialNumberInformation = true;
4906 memcpy(PhysicalDeviceInfo, NewPhysicalDeviceInfo,
4907 sizeof(DAC960_V2_PhysicalDeviceInfo_T));
4909 NewPhysicalDeviceInfo->LogicalUnit++;
4910 Controller->V2.PhysicalDeviceIndex++;
4912 else if (CommandOpcode == DAC960_V2_GetPhysicalDeviceInfoValid)
4914 unsigned int DeviceIndex;
4915 for (DeviceIndex = Controller->V2.PhysicalDeviceIndex;
4916 DeviceIndex < DAC960_V2_MaxPhysicalDevices;
4917 DeviceIndex++)
4919 DAC960_V2_PhysicalDeviceInfo_T *PhysicalDeviceInfo =
4920 Controller->V2.PhysicalDeviceInformation[DeviceIndex];
4921 DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
4922 Controller->V2.InquiryUnitSerialNumber[DeviceIndex];
4923 if (PhysicalDeviceInfo == NULL) break;
4924 DAC960_Critical("Physical Device %d:%d No Longer Exists\n",
4925 Controller,
4926 PhysicalDeviceInfo->Channel,
4927 PhysicalDeviceInfo->TargetID);
4928 Controller->V2.PhysicalDeviceInformation[DeviceIndex] = NULL;
4929 Controller->V2.InquiryUnitSerialNumber[DeviceIndex] = NULL;
4930 kfree(PhysicalDeviceInfo);
4931 kfree(InquiryUnitSerialNumber);
4933 Controller->V2.NeedPhysicalDeviceInformation = false;
4935 else if (CommandOpcode == DAC960_V2_GetLogicalDeviceInfoValid &&
4936 CommandStatus == DAC960_V2_NormalCompletion)
4938 DAC960_V2_LogicalDeviceInfo_T *NewLogicalDeviceInfo =
4939 Controller->V2.NewLogicalDeviceInformation;
4940 unsigned short LogicalDeviceNumber =
4941 NewLogicalDeviceInfo->LogicalDeviceNumber;
4942 DAC960_V2_LogicalDeviceInfo_T *LogicalDeviceInfo =
4943 Controller->V2.LogicalDeviceInformation[LogicalDeviceNumber];
4944 if (LogicalDeviceInfo == NULL)
4946 DAC960_V2_PhysicalDevice_T PhysicalDevice;
4947 PhysicalDevice.Controller = 0;
4948 PhysicalDevice.Channel = NewLogicalDeviceInfo->Channel;
4949 PhysicalDevice.TargetID = NewLogicalDeviceInfo->TargetID;
4950 PhysicalDevice.LogicalUnit = NewLogicalDeviceInfo->LogicalUnit;
4951 Controller->V2.LogicalDriveToVirtualDevice[LogicalDeviceNumber] =
4952 PhysicalDevice;
4953 LogicalDeviceInfo = (DAC960_V2_LogicalDeviceInfo_T *)
4954 kmalloc(sizeof(DAC960_V2_LogicalDeviceInfo_T), GFP_ATOMIC);
4955 Controller->V2.LogicalDeviceInformation[LogicalDeviceNumber] =
4956 LogicalDeviceInfo;
4957 DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
4958 "Now Exists%s\n", Controller,
4959 LogicalDeviceNumber,
4960 Controller->ControllerNumber,
4961 LogicalDeviceNumber,
4962 (LogicalDeviceInfo != NULL
4963 ? "" : " - Allocation Failed"));
4964 if (LogicalDeviceInfo != NULL)
4966 memset(LogicalDeviceInfo, 0,
4967 sizeof(DAC960_V2_LogicalDeviceInfo_T));
4968 DAC960_ComputeGenericDiskInfo(Controller);
4971 if (LogicalDeviceInfo != NULL)
4973 unsigned long LogicalDeviceSize =
4974 NewLogicalDeviceInfo->ConfigurableDeviceSize;
4975 if (NewLogicalDeviceInfo->LogicalDeviceState !=
4976 LogicalDeviceInfo->LogicalDeviceState)
4977 DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
4978 "is now %s\n", Controller,
4979 LogicalDeviceNumber,
4980 Controller->ControllerNumber,
4981 LogicalDeviceNumber,
4982 (NewLogicalDeviceInfo->LogicalDeviceState
4983 == DAC960_V2_LogicalDevice_Online
4984 ? "ONLINE"
4985 : NewLogicalDeviceInfo->LogicalDeviceState
4986 == DAC960_V2_LogicalDevice_Critical
4987 ? "CRITICAL" : "OFFLINE"));
4988 if ((NewLogicalDeviceInfo->SoftErrors !=
4989 LogicalDeviceInfo->SoftErrors) ||
4990 (NewLogicalDeviceInfo->CommandsFailed !=
4991 LogicalDeviceInfo->CommandsFailed) ||
4992 (NewLogicalDeviceInfo->DeferredWriteErrors !=
4993 LogicalDeviceInfo->DeferredWriteErrors))
4994 DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) Errors: "
4995 "Soft = %d, Failed = %d, Deferred Write = %d\n",
4996 Controller, LogicalDeviceNumber,
4997 Controller->ControllerNumber,
4998 LogicalDeviceNumber,
4999 NewLogicalDeviceInfo->SoftErrors,
5000 NewLogicalDeviceInfo->CommandsFailed,
5001 NewLogicalDeviceInfo->DeferredWriteErrors);
5002 if (NewLogicalDeviceInfo->ConsistencyCheckInProgress)
5003 DAC960_V2_ReportProgress(Controller,
5004 "Consistency Check",
5005 LogicalDeviceNumber,
5006 NewLogicalDeviceInfo
5007 ->ConsistencyCheckBlockNumber,
5008 LogicalDeviceSize);
5009 else if (NewLogicalDeviceInfo->RebuildInProgress)
5010 DAC960_V2_ReportProgress(Controller,
5011 "Rebuild",
5012 LogicalDeviceNumber,
5013 NewLogicalDeviceInfo
5014 ->RebuildBlockNumber,
5015 LogicalDeviceSize);
5016 else if (NewLogicalDeviceInfo->BackgroundInitializationInProgress)
5017 DAC960_V2_ReportProgress(Controller,
5018 "Background Initialization",
5019 LogicalDeviceNumber,
5020 NewLogicalDeviceInfo
5021 ->BackgroundInitializationBlockNumber,
5022 LogicalDeviceSize);
5023 else if (NewLogicalDeviceInfo->ForegroundInitializationInProgress)
5024 DAC960_V2_ReportProgress(Controller,
5025 "Foreground Initialization",
5026 LogicalDeviceNumber,
5027 NewLogicalDeviceInfo
5028 ->ForegroundInitializationBlockNumber,
5029 LogicalDeviceSize);
5030 else if (NewLogicalDeviceInfo->DataMigrationInProgress)
5031 DAC960_V2_ReportProgress(Controller,
5032 "Data Migration",
5033 LogicalDeviceNumber,
5034 NewLogicalDeviceInfo
5035 ->DataMigrationBlockNumber,
5036 LogicalDeviceSize);
5037 else if (NewLogicalDeviceInfo->PatrolOperationInProgress)
5038 DAC960_V2_ReportProgress(Controller,
5039 "Patrol Operation",
5040 LogicalDeviceNumber,
5041 NewLogicalDeviceInfo
5042 ->PatrolOperationBlockNumber,
5043 LogicalDeviceSize);
5044 if (LogicalDeviceInfo->BackgroundInitializationInProgress &&
5045 !NewLogicalDeviceInfo->BackgroundInitializationInProgress)
5046 DAC960_Progress("Logical Drive %d (/dev/rd/c%dd%d) "
5047 "Background Initialization %s\n",
5048 Controller,
5049 LogicalDeviceNumber,
5050 Controller->ControllerNumber,
5051 LogicalDeviceNumber,
5052 (NewLogicalDeviceInfo->LogicalDeviceControl
5053 .LogicalDeviceInitialized
5054 ? "Completed" : "Failed"));
5055 memcpy(LogicalDeviceInfo, NewLogicalDeviceInfo,
5056 sizeof(DAC960_V2_LogicalDeviceInfo_T));
5058 Controller->V2.LogicalDriveFoundDuringScan
5059 [LogicalDeviceNumber] = true;
5060 NewLogicalDeviceInfo->LogicalDeviceNumber++;
5062 else if (CommandOpcode == DAC960_V2_GetLogicalDeviceInfoValid)
5064 int LogicalDriveNumber;
5065 for (LogicalDriveNumber = 0;
5066 LogicalDriveNumber < DAC960_MaxLogicalDrives;
5067 LogicalDriveNumber++)
5069 DAC960_V2_LogicalDeviceInfo_T *LogicalDeviceInfo =
5070 Controller->V2.LogicalDeviceInformation[LogicalDriveNumber];
5071 if (LogicalDeviceInfo == NULL ||
5072 Controller->V2.LogicalDriveFoundDuringScan
5073 [LogicalDriveNumber])
5074 continue;
5075 DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
5076 "No Longer Exists\n", Controller,
5077 LogicalDriveNumber,
5078 Controller->ControllerNumber,
5079 LogicalDriveNumber);
5080 Controller->V2.LogicalDeviceInformation
5081 [LogicalDriveNumber] = NULL;
5082 kfree(LogicalDeviceInfo);
5083 Controller->LogicalDriveInitiallyAccessible
5084 [LogicalDriveNumber] = false;
5085 DAC960_ComputeGenericDiskInfo(Controller);
5087 Controller->V2.NeedLogicalDeviceInformation = false;
5089 else if (CommandOpcode == DAC960_V2_SCSI_10_Passthru)
5091 DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
5092 Controller->V2.InquiryUnitSerialNumber[Controller->V2.PhysicalDeviceIndex - 1];
5094 if (CommandStatus != DAC960_V2_NormalCompletion) {
5095 memset(InquiryUnitSerialNumber,
5096 0, sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
5097 InquiryUnitSerialNumber->PeripheralDeviceType = 0x1F;
5098 } else
5099 memcpy(InquiryUnitSerialNumber,
5100 Controller->V2.NewInquiryUnitSerialNumber,
5101 sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
5103 Controller->V2.NeedDeviceSerialNumberInformation = false;
5106 if (Controller->V2.HealthStatusBuffer->NextEventSequenceNumber
5107 - Controller->V2.NextEventSequenceNumber > 0)
5109 CommandMailbox->GetEvent.CommandOpcode = DAC960_V2_IOCTL;
5110 CommandMailbox->GetEvent.DataTransferSize = sizeof(DAC960_V2_Event_T);
5111 CommandMailbox->GetEvent.EventSequenceNumberHigh16 =
5112 Controller->V2.NextEventSequenceNumber >> 16;
5113 CommandMailbox->GetEvent.ControllerNumber = 0;
5114 CommandMailbox->GetEvent.IOCTL_Opcode =
5115 DAC960_V2_GetEvent;
5116 CommandMailbox->GetEvent.EventSequenceNumberLow16 =
5117 Controller->V2.NextEventSequenceNumber & 0xFFFF;
5118 CommandMailbox->GetEvent.DataTransferMemoryAddress
5119 .ScatterGatherSegments[0]
5120 .SegmentDataPointer =
5121 Controller->V2.EventDMA;
5122 CommandMailbox->GetEvent.DataTransferMemoryAddress
5123 .ScatterGatherSegments[0]
5124 .SegmentByteCount =
5125 CommandMailbox->GetEvent.DataTransferSize;
5126 DAC960_QueueCommand(Command);
5127 return;
5129 if (Controller->V2.NeedPhysicalDeviceInformation)
5131 if (Controller->V2.NeedDeviceSerialNumberInformation)
5133 DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
5134 Controller->V2.NewInquiryUnitSerialNumber;
5135 InquiryUnitSerialNumber->PeripheralDeviceType = 0x1F;
5137 DAC960_V2_ConstructNewUnitSerialNumber(Controller, CommandMailbox,
5138 Controller->V2.NewPhysicalDeviceInformation->Channel,
5139 Controller->V2.NewPhysicalDeviceInformation->TargetID,
5140 Controller->V2.NewPhysicalDeviceInformation->LogicalUnit - 1);
5143 DAC960_QueueCommand(Command);
5144 return;
5146 if (Controller->V2.StartPhysicalDeviceInformationScan)
5148 Controller->V2.PhysicalDeviceIndex = 0;
5149 Controller->V2.NewPhysicalDeviceInformation->Channel = 0;
5150 Controller->V2.NewPhysicalDeviceInformation->TargetID = 0;
5151 Controller->V2.NewPhysicalDeviceInformation->LogicalUnit = 0;
5152 Controller->V2.StartPhysicalDeviceInformationScan = false;
5154 CommandMailbox->PhysicalDeviceInfo.CommandOpcode = DAC960_V2_IOCTL;
5155 CommandMailbox->PhysicalDeviceInfo.DataTransferSize =
5156 sizeof(DAC960_V2_PhysicalDeviceInfo_T);
5157 CommandMailbox->PhysicalDeviceInfo.PhysicalDevice.LogicalUnit =
5158 Controller->V2.NewPhysicalDeviceInformation->LogicalUnit;
5159 CommandMailbox->PhysicalDeviceInfo.PhysicalDevice.TargetID =
5160 Controller->V2.NewPhysicalDeviceInformation->TargetID;
5161 CommandMailbox->PhysicalDeviceInfo.PhysicalDevice.Channel =
5162 Controller->V2.NewPhysicalDeviceInformation->Channel;
5163 CommandMailbox->PhysicalDeviceInfo.IOCTL_Opcode =
5164 DAC960_V2_GetPhysicalDeviceInfoValid;
5165 CommandMailbox->PhysicalDeviceInfo.DataTransferMemoryAddress
5166 .ScatterGatherSegments[0]
5167 .SegmentDataPointer =
5168 Controller->V2.NewPhysicalDeviceInformationDMA;
5169 CommandMailbox->PhysicalDeviceInfo.DataTransferMemoryAddress
5170 .ScatterGatherSegments[0]
5171 .SegmentByteCount =
5172 CommandMailbox->PhysicalDeviceInfo.DataTransferSize;
5173 DAC960_QueueCommand(Command);
5174 return;
5176 if (Controller->V2.NeedLogicalDeviceInformation)
5178 if (Controller->V2.StartLogicalDeviceInformationScan)
5180 int LogicalDriveNumber;
5181 for (LogicalDriveNumber = 0;
5182 LogicalDriveNumber < DAC960_MaxLogicalDrives;
5183 LogicalDriveNumber++)
5184 Controller->V2.LogicalDriveFoundDuringScan
5185 [LogicalDriveNumber] = false;
5186 Controller->V2.NewLogicalDeviceInformation->LogicalDeviceNumber = 0;
5187 Controller->V2.StartLogicalDeviceInformationScan = false;
5189 CommandMailbox->LogicalDeviceInfo.CommandOpcode = DAC960_V2_IOCTL;
5190 CommandMailbox->LogicalDeviceInfo.DataTransferSize =
5191 sizeof(DAC960_V2_LogicalDeviceInfo_T);
5192 CommandMailbox->LogicalDeviceInfo.LogicalDevice.LogicalDeviceNumber =
5193 Controller->V2.NewLogicalDeviceInformation->LogicalDeviceNumber;
5194 CommandMailbox->LogicalDeviceInfo.IOCTL_Opcode =
5195 DAC960_V2_GetLogicalDeviceInfoValid;
5196 CommandMailbox->LogicalDeviceInfo.DataTransferMemoryAddress
5197 .ScatterGatherSegments[0]
5198 .SegmentDataPointer =
5199 Controller->V2.NewLogicalDeviceInformationDMA;
5200 CommandMailbox->LogicalDeviceInfo.DataTransferMemoryAddress
5201 .ScatterGatherSegments[0]
5202 .SegmentByteCount =
5203 CommandMailbox->LogicalDeviceInfo.DataTransferSize;
5204 DAC960_QueueCommand(Command);
5205 return;
5207 Controller->MonitoringTimerCount++;
5208 Controller->MonitoringTimer.expires =
5209 jiffies + DAC960_HealthStatusMonitoringInterval;
5210 add_timer(&Controller->MonitoringTimer);
5212 if (CommandType == DAC960_ImmediateCommand)
5214 complete(Command->Completion);
5215 Command->Completion = NULL;
5216 return;
5218 if (CommandType == DAC960_QueuedCommand)
5220 DAC960_V2_KernelCommand_T *KernelCommand = Command->V2.KernelCommand;
5221 KernelCommand->CommandStatus = CommandStatus;
5222 KernelCommand->RequestSenseLength = Command->V2.RequestSenseLength;
5223 KernelCommand->DataTransferLength = Command->V2.DataTransferResidue;
5224 Command->V2.KernelCommand = NULL;
5225 DAC960_DeallocateCommand(Command);
5226 KernelCommand->CompletionFunction(KernelCommand);
5227 return;
5229 /*
5230 Queue a Status Monitoring Command to the Controller using the just
5231 completed Command if one was deferred previously due to lack of a
5232 free Command when the Monitoring Timer Function was called.
5233 */
5234 if (Controller->MonitoringCommandDeferred)
5236 Controller->MonitoringCommandDeferred = false;
5237 DAC960_V2_QueueMonitoringCommand(Command);
5238 return;
5240 /*
5241 Deallocate the Command.
5242 */
5243 DAC960_DeallocateCommand(Command);
5244 /*
5245 Wake up any processes waiting on a free Command.
5246 */
5247 wake_up(&Controller->CommandWaitQueue);
5250 /*
5251 DAC960_GEM_InterruptHandler handles hardware interrupts from DAC960 GEM Series
5252 Controllers.
5253 */
5255 static irqreturn_t DAC960_GEM_InterruptHandler(int IRQ_Channel,
5256 void *DeviceIdentifier,
5257 struct pt_regs *InterruptRegisters)
5259 DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
5260 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
5261 DAC960_V2_StatusMailbox_T *NextStatusMailbox;
5262 unsigned long flags;
5264 spin_lock_irqsave(&Controller->queue_lock, flags);
5265 DAC960_GEM_AcknowledgeInterrupt(ControllerBaseAddress);
5266 NextStatusMailbox = Controller->V2.NextStatusMailbox;
5267 while (NextStatusMailbox->Fields.CommandIdentifier > 0)
5269 DAC960_V2_CommandIdentifier_T CommandIdentifier =
5270 NextStatusMailbox->Fields.CommandIdentifier;
5271 DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
5272 Command->V2.CommandStatus = NextStatusMailbox->Fields.CommandStatus;
5273 Command->V2.RequestSenseLength =
5274 NextStatusMailbox->Fields.RequestSenseLength;
5275 Command->V2.DataTransferResidue =
5276 NextStatusMailbox->Fields.DataTransferResidue;
5277 NextStatusMailbox->Words[0] = 0;
5278 if (++NextStatusMailbox > Controller->V2.LastStatusMailbox)
5279 NextStatusMailbox = Controller->V2.FirstStatusMailbox;
5280 DAC960_V2_ProcessCompletedCommand(Command);
5282 Controller->V2.NextStatusMailbox = NextStatusMailbox;
5283 /*
5284 Attempt to remove additional I/O Requests from the Controller's
5285 I/O Request Queue and queue them to the Controller.
5286 */
5287 DAC960_ProcessRequest(Controller);
5288 spin_unlock_irqrestore(&Controller->queue_lock, flags);
5289 return IRQ_HANDLED;
5292 /*
5293 DAC960_BA_InterruptHandler handles hardware interrupts from DAC960 BA Series
5294 Controllers.
5295 */
5297 static irqreturn_t DAC960_BA_InterruptHandler(int IRQ_Channel,
5298 void *DeviceIdentifier,
5299 struct pt_regs *InterruptRegisters)
5301 DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
5302 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
5303 DAC960_V2_StatusMailbox_T *NextStatusMailbox;
5304 unsigned long flags;
5306 spin_lock_irqsave(&Controller->queue_lock, flags);
5307 DAC960_BA_AcknowledgeInterrupt(ControllerBaseAddress);
5308 NextStatusMailbox = Controller->V2.NextStatusMailbox;
5309 while (NextStatusMailbox->Fields.CommandIdentifier > 0)
5311 DAC960_V2_CommandIdentifier_T CommandIdentifier =
5312 NextStatusMailbox->Fields.CommandIdentifier;
5313 DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
5314 Command->V2.CommandStatus = NextStatusMailbox->Fields.CommandStatus;
5315 Command->V2.RequestSenseLength =
5316 NextStatusMailbox->Fields.RequestSenseLength;
5317 Command->V2.DataTransferResidue =
5318 NextStatusMailbox->Fields.DataTransferResidue;
5319 NextStatusMailbox->Words[0] = 0;
5320 if (++NextStatusMailbox > Controller->V2.LastStatusMailbox)
5321 NextStatusMailbox = Controller->V2.FirstStatusMailbox;
5322 DAC960_V2_ProcessCompletedCommand(Command);
5324 Controller->V2.NextStatusMailbox = NextStatusMailbox;
5325 /*
5326 Attempt to remove additional I/O Requests from the Controller's
5327 I/O Request Queue and queue them to the Controller.
5328 */
5329 DAC960_ProcessRequest(Controller);
5330 spin_unlock_irqrestore(&Controller->queue_lock, flags);
5331 return IRQ_HANDLED;
5335 /*
5336 DAC960_LP_InterruptHandler handles hardware interrupts from DAC960 LP Series
5337 Controllers.
5338 */
5340 static irqreturn_t DAC960_LP_InterruptHandler(int IRQ_Channel,
5341 void *DeviceIdentifier,
5342 struct pt_regs *InterruptRegisters)
5344 DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
5345 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
5346 DAC960_V2_StatusMailbox_T *NextStatusMailbox;
5347 unsigned long flags;
5349 spin_lock_irqsave(&Controller->queue_lock, flags);
5350 DAC960_LP_AcknowledgeInterrupt(ControllerBaseAddress);
5351 NextStatusMailbox = Controller->V2.NextStatusMailbox;
5352 while (NextStatusMailbox->Fields.CommandIdentifier > 0)
5354 DAC960_V2_CommandIdentifier_T CommandIdentifier =
5355 NextStatusMailbox->Fields.CommandIdentifier;
5356 DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
5357 Command->V2.CommandStatus = NextStatusMailbox->Fields.CommandStatus;
5358 Command->V2.RequestSenseLength =
5359 NextStatusMailbox->Fields.RequestSenseLength;
5360 Command->V2.DataTransferResidue =
5361 NextStatusMailbox->Fields.DataTransferResidue;
5362 NextStatusMailbox->Words[0] = 0;
5363 if (++NextStatusMailbox > Controller->V2.LastStatusMailbox)
5364 NextStatusMailbox = Controller->V2.FirstStatusMailbox;
5365 DAC960_V2_ProcessCompletedCommand(Command);
5367 Controller->V2.NextStatusMailbox = NextStatusMailbox;
5368 /*
5369 Attempt to remove additional I/O Requests from the Controller's
5370 I/O Request Queue and queue them to the Controller.
5371 */
5372 DAC960_ProcessRequest(Controller);
5373 spin_unlock_irqrestore(&Controller->queue_lock, flags);
5374 return IRQ_HANDLED;
5378 /*
5379 DAC960_LA_InterruptHandler handles hardware interrupts from DAC960 LA Series
5380 Controllers.
5381 */
5383 static irqreturn_t DAC960_LA_InterruptHandler(int IRQ_Channel,
5384 void *DeviceIdentifier,
5385 struct pt_regs *InterruptRegisters)
5387 DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
5388 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
5389 DAC960_V1_StatusMailbox_T *NextStatusMailbox;
5390 unsigned long flags;
5392 spin_lock_irqsave(&Controller->queue_lock, flags);
5393 DAC960_LA_AcknowledgeInterrupt(ControllerBaseAddress);
5394 NextStatusMailbox = Controller->V1.NextStatusMailbox;
5395 while (NextStatusMailbox->Fields.Valid)
5397 DAC960_V1_CommandIdentifier_T CommandIdentifier =
5398 NextStatusMailbox->Fields.CommandIdentifier;
5399 DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
5400 Command->V1.CommandStatus = NextStatusMailbox->Fields.CommandStatus;
5401 NextStatusMailbox->Word = 0;
5402 if (++NextStatusMailbox > Controller->V1.LastStatusMailbox)
5403 NextStatusMailbox = Controller->V1.FirstStatusMailbox;
5404 DAC960_V1_ProcessCompletedCommand(Command);
5406 Controller->V1.NextStatusMailbox = NextStatusMailbox;
5407 /*
5408 Attempt to remove additional I/O Requests from the Controller's
5409 I/O Request Queue and queue them to the Controller.
5410 */
5411 DAC960_ProcessRequest(Controller);
5412 spin_unlock_irqrestore(&Controller->queue_lock, flags);
5413 return IRQ_HANDLED;
5417 /*
5418 DAC960_PG_InterruptHandler handles hardware interrupts from DAC960 PG Series
5419 Controllers.
5420 */
5422 static irqreturn_t DAC960_PG_InterruptHandler(int IRQ_Channel,
5423 void *DeviceIdentifier,
5424 struct pt_regs *InterruptRegisters)
5426 DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
5427 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
5428 DAC960_V1_StatusMailbox_T *NextStatusMailbox;
5429 unsigned long flags;
5431 spin_lock_irqsave(&Controller->queue_lock, flags);
5432 DAC960_PG_AcknowledgeInterrupt(ControllerBaseAddress);
5433 NextStatusMailbox = Controller->V1.NextStatusMailbox;
5434 while (NextStatusMailbox->Fields.Valid)
5436 DAC960_V1_CommandIdentifier_T CommandIdentifier =
5437 NextStatusMailbox->Fields.CommandIdentifier;
5438 DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
5439 Command->V1.CommandStatus = NextStatusMailbox->Fields.CommandStatus;
5440 NextStatusMailbox->Word = 0;
5441 if (++NextStatusMailbox > Controller->V1.LastStatusMailbox)
5442 NextStatusMailbox = Controller->V1.FirstStatusMailbox;
5443 DAC960_V1_ProcessCompletedCommand(Command);
5445 Controller->V1.NextStatusMailbox = NextStatusMailbox;
5446 /*
5447 Attempt to remove additional I/O Requests from the Controller's
5448 I/O Request Queue and queue them to the Controller.
5449 */
5450 DAC960_ProcessRequest(Controller);
5451 spin_unlock_irqrestore(&Controller->queue_lock, flags);
5452 return IRQ_HANDLED;
5456 /*
5457 DAC960_PD_InterruptHandler handles hardware interrupts from DAC960 PD Series
5458 Controllers.
5459 */
5461 static irqreturn_t DAC960_PD_InterruptHandler(int IRQ_Channel,
5462 void *DeviceIdentifier,
5463 struct pt_regs *InterruptRegisters)
5465 DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
5466 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
5467 unsigned long flags;
5469 spin_lock_irqsave(&Controller->queue_lock, flags);
5470 while (DAC960_PD_StatusAvailableP(ControllerBaseAddress))
5472 DAC960_V1_CommandIdentifier_T CommandIdentifier =
5473 DAC960_PD_ReadStatusCommandIdentifier(ControllerBaseAddress);
5474 DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
5475 Command->V1.CommandStatus =
5476 DAC960_PD_ReadStatusRegister(ControllerBaseAddress);
5477 DAC960_PD_AcknowledgeInterrupt(ControllerBaseAddress);
5478 DAC960_PD_AcknowledgeStatus(ControllerBaseAddress);
5479 DAC960_V1_ProcessCompletedCommand(Command);
5481 /*
5482 Attempt to remove additional I/O Requests from the Controller's
5483 I/O Request Queue and queue them to the Controller.
5484 */
5485 DAC960_ProcessRequest(Controller);
5486 spin_unlock_irqrestore(&Controller->queue_lock, flags);
5487 return IRQ_HANDLED;
5491 /*
5492 DAC960_P_InterruptHandler handles hardware interrupts from DAC960 P Series
5493 Controllers.
5495 Translations of DAC960_V1_Enquiry and DAC960_V1_GetDeviceState rely
5496 on the data having been placed into DAC960_Controller_T, rather than
5497 an arbitrary buffer.
5498 */
5500 static irqreturn_t DAC960_P_InterruptHandler(int IRQ_Channel,
5501 void *DeviceIdentifier,
5502 struct pt_regs *InterruptRegisters)
5504 DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
5505 void __iomem *ControllerBaseAddress = Controller->BaseAddress;
5506 unsigned long flags;
5508 spin_lock_irqsave(&Controller->queue_lock, flags);
5509 while (DAC960_PD_StatusAvailableP(ControllerBaseAddress))
5511 DAC960_V1_CommandIdentifier_T CommandIdentifier =
5512 DAC960_PD_ReadStatusCommandIdentifier(ControllerBaseAddress);
5513 DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
5514 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
5515 DAC960_V1_CommandOpcode_T CommandOpcode =
5516 CommandMailbox->Common.CommandOpcode;
5517 Command->V1.CommandStatus =
5518 DAC960_PD_ReadStatusRegister(ControllerBaseAddress);
5519 DAC960_PD_AcknowledgeInterrupt(ControllerBaseAddress);
5520 DAC960_PD_AcknowledgeStatus(ControllerBaseAddress);
5521 switch (CommandOpcode)
5523 case DAC960_V1_Enquiry_Old:
5524 Command->V1.CommandMailbox.Common.CommandOpcode = DAC960_V1_Enquiry;
5525 DAC960_P_To_PD_TranslateEnquiry(Controller->V1.NewEnquiry);
5526 break;
5527 case DAC960_V1_GetDeviceState_Old:
5528 Command->V1.CommandMailbox.Common.CommandOpcode =
5529 DAC960_V1_GetDeviceState;
5530 DAC960_P_To_PD_TranslateDeviceState(Controller->V1.NewDeviceState);
5531 break;
5532 case DAC960_V1_Read_Old:
5533 Command->V1.CommandMailbox.Common.CommandOpcode = DAC960_V1_Read;
5534 DAC960_P_To_PD_TranslateReadWriteCommand(CommandMailbox);
5535 break;
5536 case DAC960_V1_Write_Old:
5537 Command->V1.CommandMailbox.Common.CommandOpcode = DAC960_V1_Write;
5538 DAC960_P_To_PD_TranslateReadWriteCommand(CommandMailbox);
5539 break;
5540 case DAC960_V1_ReadWithScatterGather_Old:
5541 Command->V1.CommandMailbox.Common.CommandOpcode =
5542 DAC960_V1_ReadWithScatterGather;
5543 DAC960_P_To_PD_TranslateReadWriteCommand(CommandMailbox);
5544 break;
5545 case DAC960_V1_WriteWithScatterGather_Old:
5546 Command->V1.CommandMailbox.Common.CommandOpcode =
5547 DAC960_V1_WriteWithScatterGather;
5548 DAC960_P_To_PD_TranslateReadWriteCommand(CommandMailbox);
5549 break;
5550 default:
5551 break;
5553 DAC960_V1_ProcessCompletedCommand(Command);
5555 /*
5556 Attempt to remove additional I/O Requests from the Controller's
5557 I/O Request Queue and queue them to the Controller.
5558 */
5559 DAC960_ProcessRequest(Controller);
5560 spin_unlock_irqrestore(&Controller->queue_lock, flags);
5561 return IRQ_HANDLED;
5565 /*
5566 DAC960_V1_QueueMonitoringCommand queues a Monitoring Command to DAC960 V1
5567 Firmware Controllers.
5568 */
5570 static void DAC960_V1_QueueMonitoringCommand(DAC960_Command_T *Command)
5572 DAC960_Controller_T *Controller = Command->Controller;
5573 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
5574 DAC960_V1_ClearCommand(Command);
5575 Command->CommandType = DAC960_MonitoringCommand;
5576 CommandMailbox->Type3.CommandOpcode = DAC960_V1_Enquiry;
5577 CommandMailbox->Type3.BusAddress = Controller->V1.NewEnquiryDMA;
5578 DAC960_QueueCommand(Command);
5582 /*
5583 DAC960_V2_QueueMonitoringCommand queues a Monitoring Command to DAC960 V2
5584 Firmware Controllers.
5585 */
5587 static void DAC960_V2_QueueMonitoringCommand(DAC960_Command_T *Command)
5589 DAC960_Controller_T *Controller = Command->Controller;
5590 DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
5591 DAC960_V2_ClearCommand(Command);
5592 Command->CommandType = DAC960_MonitoringCommand;
5593 CommandMailbox->ControllerInfo.CommandOpcode = DAC960_V2_IOCTL;
5594 CommandMailbox->ControllerInfo.CommandControlBits
5595 .DataTransferControllerToHost = true;
5596 CommandMailbox->ControllerInfo.CommandControlBits
5597 .NoAutoRequestSense = true;
5598 CommandMailbox->ControllerInfo.DataTransferSize =
5599 sizeof(DAC960_V2_ControllerInfo_T);
5600 CommandMailbox->ControllerInfo.ControllerNumber = 0;
5601 CommandMailbox->ControllerInfo.IOCTL_Opcode = DAC960_V2_GetControllerInfo;
5602 CommandMailbox->ControllerInfo.DataTransferMemoryAddress
5603 .ScatterGatherSegments[0]
5604 .SegmentDataPointer =
5605 Controller->V2.NewControllerInformationDMA;
5606 CommandMailbox->ControllerInfo.DataTransferMemoryAddress
5607 .ScatterGatherSegments[0]
5608 .SegmentByteCount =
5609 CommandMailbox->ControllerInfo.DataTransferSize;
5610 DAC960_QueueCommand(Command);
5614 /*
5615 DAC960_MonitoringTimerFunction is the timer function for monitoring
5616 the status of DAC960 Controllers.
5617 */
5619 static void DAC960_MonitoringTimerFunction(unsigned long TimerData)
5621 DAC960_Controller_T *Controller = (DAC960_Controller_T *) TimerData;
5622 DAC960_Command_T *Command;
5623 unsigned long flags;
5625 if (Controller->FirmwareType == DAC960_V1_Controller)
5627 spin_lock_irqsave(&Controller->queue_lock, flags);
5628 /*
5629 Queue a Status Monitoring Command to Controller.
5630 */
5631 Command = DAC960_AllocateCommand(Controller);
5632 if (Command != NULL)
5633 DAC960_V1_QueueMonitoringCommand(Command);
5634 else Controller->MonitoringCommandDeferred = true;
5635 spin_unlock_irqrestore(&Controller->queue_lock, flags);
5637 else
5639 DAC960_V2_ControllerInfo_T *ControllerInfo =
5640 &Controller->V2.ControllerInformation;
5641 unsigned int StatusChangeCounter =
5642 Controller->V2.HealthStatusBuffer->StatusChangeCounter;
5643 boolean ForceMonitoringCommand = false;
5644 if (time_after(jiffies, Controller->SecondaryMonitoringTime
5645 + DAC960_SecondaryMonitoringInterval))
5647 int LogicalDriveNumber;
5648 for (LogicalDriveNumber = 0;
5649 LogicalDriveNumber < DAC960_MaxLogicalDrives;
5650 LogicalDriveNumber++)
5652 DAC960_V2_LogicalDeviceInfo_T *LogicalDeviceInfo =
5653 Controller->V2.LogicalDeviceInformation[LogicalDriveNumber];
5654 if (LogicalDeviceInfo == NULL) continue;
5655 if (!LogicalDeviceInfo->LogicalDeviceControl
5656 .LogicalDeviceInitialized)
5658 ForceMonitoringCommand = true;
5659 break;
5662 Controller->SecondaryMonitoringTime = jiffies;
5664 if (StatusChangeCounter == Controller->V2.StatusChangeCounter &&
5665 Controller->V2.HealthStatusBuffer->NextEventSequenceNumber
5666 == Controller->V2.NextEventSequenceNumber &&
5667 (ControllerInfo->BackgroundInitializationsActive +
5668 ControllerInfo->LogicalDeviceInitializationsActive +
5669 ControllerInfo->PhysicalDeviceInitializationsActive +
5670 ControllerInfo->ConsistencyChecksActive +
5671 ControllerInfo->RebuildsActive +
5672 ControllerInfo->OnlineExpansionsActive == 0 ||
5673 time_before(jiffies, Controller->PrimaryMonitoringTime
5674 + DAC960_MonitoringTimerInterval)) &&
5675 !ForceMonitoringCommand)
5677 Controller->MonitoringTimer.expires =
5678 jiffies + DAC960_HealthStatusMonitoringInterval;
5679 add_timer(&Controller->MonitoringTimer);
5680 return;
5682 Controller->V2.StatusChangeCounter = StatusChangeCounter;
5683 Controller->PrimaryMonitoringTime = jiffies;
5685 spin_lock_irqsave(&Controller->queue_lock, flags);
5686 /*
5687 Queue a Status Monitoring Command to Controller.
5688 */
5689 Command = DAC960_AllocateCommand(Controller);
5690 if (Command != NULL)
5691 DAC960_V2_QueueMonitoringCommand(Command);
5692 else Controller->MonitoringCommandDeferred = true;
5693 spin_unlock_irqrestore(&Controller->queue_lock, flags);
5694 /*
5695 Wake up any processes waiting on a Health Status Buffer change.
5696 */
5697 wake_up(&Controller->HealthStatusWaitQueue);
5701 /*
5702 DAC960_CheckStatusBuffer verifies that there is room to hold ByteCount
5703 additional bytes in the Combined Status Buffer and grows the buffer if
5704 necessary. It returns true if there is enough room and false otherwise.
5705 */
5707 static boolean DAC960_CheckStatusBuffer(DAC960_Controller_T *Controller,
5708 unsigned int ByteCount)
5710 unsigned char *NewStatusBuffer;
5711 if (Controller->InitialStatusLength + 1 +
5712 Controller->CurrentStatusLength + ByteCount + 1 <=
5713 Controller->CombinedStatusBufferLength)
5714 return true;
5715 if (Controller->CombinedStatusBufferLength == 0)
5717 unsigned int NewStatusBufferLength = DAC960_InitialStatusBufferSize;
5718 while (NewStatusBufferLength < ByteCount)
5719 NewStatusBufferLength *= 2;
5720 Controller->CombinedStatusBuffer =
5721 (unsigned char *) kmalloc(NewStatusBufferLength, GFP_ATOMIC);
5722 if (Controller->CombinedStatusBuffer == NULL) return false;
5723 Controller->CombinedStatusBufferLength = NewStatusBufferLength;
5724 return true;
5726 NewStatusBuffer = (unsigned char *)
5727 kmalloc(2 * Controller->CombinedStatusBufferLength, GFP_ATOMIC);
5728 if (NewStatusBuffer == NULL)
5730 DAC960_Warning("Unable to expand Combined Status Buffer - Truncating\n",
5731 Controller);
5732 return false;
5734 memcpy(NewStatusBuffer, Controller->CombinedStatusBuffer,
5735 Controller->CombinedStatusBufferLength);
5736 kfree(Controller->CombinedStatusBuffer);
5737 Controller->CombinedStatusBuffer = NewStatusBuffer;
5738 Controller->CombinedStatusBufferLength *= 2;
5739 Controller->CurrentStatusBuffer =
5740 &NewStatusBuffer[Controller->InitialStatusLength + 1];
5741 return true;
5745 /*
5746 DAC960_Message prints Driver Messages.
5747 */
5749 static void DAC960_Message(DAC960_MessageLevel_T MessageLevel,
5750 unsigned char *Format,
5751 DAC960_Controller_T *Controller,
5752 ...)
5754 static unsigned char Buffer[DAC960_LineBufferSize];
5755 static boolean BeginningOfLine = true;
5756 va_list Arguments;
5757 int Length = 0;
5758 va_start(Arguments, Controller);
5759 Length = vsprintf(Buffer, Format, Arguments);
5760 va_end(Arguments);
5761 if (Controller == NULL)
5762 printk("%sDAC960#%d: %s", DAC960_MessageLevelMap[MessageLevel],
5763 DAC960_ControllerCount, Buffer);
5764 else if (MessageLevel == DAC960_AnnounceLevel ||
5765 MessageLevel == DAC960_InfoLevel)
5767 if (!Controller->ControllerInitialized)
5769 if (DAC960_CheckStatusBuffer(Controller, Length))
5771 strcpy(&Controller->CombinedStatusBuffer
5772 [Controller->InitialStatusLength],
5773 Buffer);
5774 Controller->InitialStatusLength += Length;
5775 Controller->CurrentStatusBuffer =
5776 &Controller->CombinedStatusBuffer
5777 [Controller->InitialStatusLength + 1];
5779 if (MessageLevel == DAC960_AnnounceLevel)
5781 static int AnnouncementLines = 0;
5782 if (++AnnouncementLines <= 2)
5783 printk("%sDAC960: %s", DAC960_MessageLevelMap[MessageLevel],
5784 Buffer);
5786 else
5788 if (BeginningOfLine)
5790 if (Buffer[0] != '\n' || Length > 1)
5791 printk("%sDAC960#%d: %s",
5792 DAC960_MessageLevelMap[MessageLevel],
5793 Controller->ControllerNumber, Buffer);
5795 else printk("%s", Buffer);
5798 else if (DAC960_CheckStatusBuffer(Controller, Length))
5800 strcpy(&Controller->CurrentStatusBuffer[
5801 Controller->CurrentStatusLength], Buffer);
5802 Controller->CurrentStatusLength += Length;
5805 else if (MessageLevel == DAC960_ProgressLevel)
5807 strcpy(Controller->ProgressBuffer, Buffer);
5808 Controller->ProgressBufferLength = Length;
5809 if (Controller->EphemeralProgressMessage)
5811 if (time_after_eq(jiffies, Controller->LastProgressReportTime
5812 + DAC960_ProgressReportingInterval))
5814 printk("%sDAC960#%d: %s", DAC960_MessageLevelMap[MessageLevel],
5815 Controller->ControllerNumber, Buffer);
5816 Controller->LastProgressReportTime = jiffies;
5819 else printk("%sDAC960#%d: %s", DAC960_MessageLevelMap[MessageLevel],
5820 Controller->ControllerNumber, Buffer);
5822 else if (MessageLevel == DAC960_UserCriticalLevel)
5824 strcpy(&Controller->UserStatusBuffer[Controller->UserStatusLength],
5825 Buffer);
5826 Controller->UserStatusLength += Length;
5827 if (Buffer[0] != '\n' || Length > 1)
5828 printk("%sDAC960#%d: %s", DAC960_MessageLevelMap[MessageLevel],
5829 Controller->ControllerNumber, Buffer);
5831 else
5833 if (BeginningOfLine)
5834 printk("%sDAC960#%d: %s", DAC960_MessageLevelMap[MessageLevel],
5835 Controller->ControllerNumber, Buffer);
5836 else printk("%s", Buffer);
5838 BeginningOfLine = (Buffer[Length-1] == '\n');
5842 /*
5843 DAC960_ParsePhysicalDevice parses spaces followed by a Physical Device
5844 Channel:TargetID specification from a User Command string. It updates
5845 Channel and TargetID and returns true on success and false on failure.
5846 */
5848 static boolean DAC960_ParsePhysicalDevice(DAC960_Controller_T *Controller,
5849 char *UserCommandString,
5850 unsigned char *Channel,
5851 unsigned char *TargetID)
5853 char *NewUserCommandString = UserCommandString;
5854 unsigned long XChannel, XTargetID;
5855 while (*UserCommandString == ' ') UserCommandString++;
5856 if (UserCommandString == NewUserCommandString)
5857 return false;
5858 XChannel = simple_strtoul(UserCommandString, &NewUserCommandString, 10);
5859 if (NewUserCommandString == UserCommandString ||
5860 *NewUserCommandString != ':' ||
5861 XChannel >= Controller->Channels)
5862 return false;
5863 UserCommandString = ++NewUserCommandString;
5864 XTargetID = simple_strtoul(UserCommandString, &NewUserCommandString, 10);
5865 if (NewUserCommandString == UserCommandString ||
5866 *NewUserCommandString != '\0' ||
5867 XTargetID >= Controller->Targets)
5868 return false;
5869 *Channel = XChannel;
5870 *TargetID = XTargetID;
5871 return true;
5875 /*
5876 DAC960_ParseLogicalDrive parses spaces followed by a Logical Drive Number
5877 specification from a User Command string. It updates LogicalDriveNumber and
5878 returns true on success and false on failure.
5879 */
5881 static boolean DAC960_ParseLogicalDrive(DAC960_Controller_T *Controller,
5882 char *UserCommandString,
5883 unsigned char *LogicalDriveNumber)
5885 char *NewUserCommandString = UserCommandString;
5886 unsigned long XLogicalDriveNumber;
5887 while (*UserCommandString == ' ') UserCommandString++;
5888 if (UserCommandString == NewUserCommandString)
5889 return false;
5890 XLogicalDriveNumber =
5891 simple_strtoul(UserCommandString, &NewUserCommandString, 10);
5892 if (NewUserCommandString == UserCommandString ||
5893 *NewUserCommandString != '\0' ||
5894 XLogicalDriveNumber > DAC960_MaxLogicalDrives - 1)
5895 return false;
5896 *LogicalDriveNumber = XLogicalDriveNumber;
5897 return true;
5901 /*
5902 DAC960_V1_SetDeviceState sets the Device State for a Physical Device for
5903 DAC960 V1 Firmware Controllers.
5904 */
5906 static void DAC960_V1_SetDeviceState(DAC960_Controller_T *Controller,
5907 DAC960_Command_T *Command,
5908 unsigned char Channel,
5909 unsigned char TargetID,
5910 DAC960_V1_PhysicalDeviceState_T
5911 DeviceState,
5912 const unsigned char *DeviceStateString)
5914 DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
5915 CommandMailbox->Type3D.CommandOpcode = DAC960_V1_StartDevice;
5916 CommandMailbox->Type3D.Channel = Channel;
5917 CommandMailbox->Type3D.TargetID = TargetID;
5918 CommandMailbox->Type3D.DeviceState = DeviceState;
5919 CommandMailbox->Type3D.Modifier = 0;
5920 DAC960_ExecuteCommand(Command);
5921 switch (Command->V1.CommandStatus)
5923 case DAC960_V1_NormalCompletion:
5924 DAC960_UserCritical("%s of Physical Device %d:%d Succeeded\n", Controller,
5925 DeviceStateString, Channel, TargetID);
5926 break;
5927 case DAC960_V1_UnableToStartDevice:
5928 DAC960_UserCritical("%s of Physical Device %d:%d Failed - "
5929 "Unable to Start Device\n", Controller,
5930 DeviceStateString, Channel, TargetID);
5931 break;
5932 case DAC960_V1_NoDeviceAtAddress:
5933 DAC960_UserCritical("%s of Physical Device %d:%d Failed - "
5934 "No Device at Address\n", Controller,
5935 DeviceStateString, Channel, TargetID);
5936 break;
5937 case DAC960_V1_InvalidChannelOrTargetOrModifier:
5938 DAC960_UserCritical("%s of Physical Device %d:%d Failed - "
5939 "Invalid Channel or Target or Modifier\n",
5940 Controller, DeviceStateString, Channel, TargetID);
5941 break;
5942 case DAC960_V1_ChannelBusy:
5943 DAC960_UserCritical("%s of Physical Device %d:%d Failed - "
5944 "Channel Busy\n", Controller,
5945 DeviceStateString, Channel, TargetID);
5946 break;
5947 default:
5948 DAC960_UserCritical("%s of Physical Device %d:%d Failed - "
5949 "Unexpected Status %04X\n", Controller,
5950 DeviceStateString, Channel, TargetID,
5951 Command->V1.CommandStatus);
5952 break;
5957 /*
5958 DAC960_V1_ExecuteUserCommand executes a User Command for DAC960 V1 Firmware
5959 Controllers.
5960 */
5962 static boolean DAC960_V1_ExecuteUserCommand(DAC960_Controller_T *Controller,
5963 unsigned char *UserCommand)
5965 DAC960_Command_T *Command;
5966 DAC960_V1_CommandMailbox_T *CommandMailbox;
5967 unsigned long flags;
5968 unsigned char Channel, TargetID, LogicalDriveNumber;
5970 spin_lock_irqsave(&Controller->queue_lock, flags);
5971 while ((Command = DAC960_AllocateCommand(Controller)) == NULL)
5972 DAC960_WaitForCommand(Controller);
5973 spin_unlock_irqrestore(&Controller->queue_lock, flags);
5974 Controller->UserStatusLength = 0;
5975 DAC960_V1_ClearCommand(Command);
5976 Command->CommandType = DAC960_ImmediateCommand;
5977 CommandMailbox = &Command->V1.CommandMailbox;
5978 if (strcmp(UserCommand, "flush-cache") == 0)
5980 CommandMailbox->Type3.CommandOpcode = DAC960_V1_Flush;
5981 DAC960_ExecuteCommand(Command);
5982 DAC960_UserCritical("Cache Flush Completed\n", Controller);
5984 else if (strncmp(UserCommand, "kill", 4) == 0 &&
5985 DAC960_ParsePhysicalDevice(Controller, &UserCommand[4],
5986 &Channel, &TargetID))
5988 DAC960_V1_DeviceState_T *DeviceState =
5989 &Controller->V1.DeviceState[Channel][TargetID];
5990 if (DeviceState->Present &&
5991 DeviceState->DeviceType == DAC960_V1_DiskType &&
5992 DeviceState->DeviceState != DAC960_V1_Device_Dead)
5993 DAC960_V1_SetDeviceState(Controller, Command, Channel, TargetID,
5994 DAC960_V1_Device_Dead, "Kill");
5995 else DAC960_UserCritical("Kill of Physical Device %d:%d Illegal\n",
5996 Controller, Channel, TargetID);
5998 else if (strncmp(UserCommand, "make-online", 11) == 0 &&
5999 DAC960_ParsePhysicalDevice(Controller, &UserCommand[11],
6000 &Channel, &TargetID))
6002 DAC960_V1_DeviceState_T *DeviceState =
6003 &Controller->V1.DeviceState[Channel][TargetID];
6004 if (DeviceState->Present &&
6005 DeviceState->DeviceType == DAC960_V1_DiskType &&
6006 DeviceState->DeviceState == DAC960_V1_Device_Dead)
6007 DAC960_V1_SetDeviceState(Controller, Command, Channel, TargetID,
6008 DAC960_V1_Device_Online, "Make Online");
6009 else DAC960_UserCritical("Make Online of Physical Device %d:%d Illegal\n",
6010 Controller, Channel, TargetID);
6013 else if (strncmp(UserCommand, "make-standby", 12) == 0 &&
6014 DAC960_ParsePhysicalDevice(Controller, &UserCommand[12],
6015 &Channel, &TargetID))
6017 DAC960_V1_DeviceState_T *DeviceState =
6018 &Controller->V1.DeviceState[Channel][TargetID];
6019 if (DeviceState->Present &&
6020 DeviceState->DeviceType == DAC960_V1_DiskType &&
6021 DeviceState->DeviceState == DAC960_V1_Device_Dead)
6022 DAC960_V1_SetDeviceState(Controller, Command, Channel, TargetID,
6023 DAC960_V1_Device_Standby, "Make Standby");
6024 else DAC960_UserCritical("Make Standby of Physical "
6025 "Device %d:%d Illegal\n",
6026 Controller, Channel, TargetID);
6028 else if (strncmp(UserCommand, "rebuild", 7) == 0 &&
6029 DAC960_ParsePhysicalDevice(Controller, &UserCommand[7],
6030 &Channel, &TargetID))
6032 CommandMailbox->Type3D.CommandOpcode = DAC960_V1_RebuildAsync;
6033 CommandMailbox->Type3D.Channel = Channel;
6034 CommandMailbox->Type3D.TargetID = TargetID;
6035 DAC960_ExecuteCommand(Command);
6036 switch (Command->V1.CommandStatus)
6038 case DAC960_V1_NormalCompletion:
6039 DAC960_UserCritical("Rebuild of Physical Device %d:%d Initiated\n",
6040 Controller, Channel, TargetID);
6041 break;
6042 case DAC960_V1_AttemptToRebuildOnlineDrive:
6043 DAC960_UserCritical("Rebuild of Physical Device %d:%d Failed - "
6044 "Attempt to Rebuild Online or "
6045 "Unresponsive Drive\n",
6046 Controller, Channel, TargetID);
6047 break;
6048 case DAC960_V1_NewDiskFailedDuringRebuild:
6049 DAC960_UserCritical("Rebuild of Physical Device %d:%d Failed - "
6050 "New Disk Failed During Rebuild\n",
6051 Controller, Channel, TargetID);
6052 break;
6053 case DAC960_V1_InvalidDeviceAddress:
6054 DAC960_UserCritical("Rebuild of Physical Device %d:%d Failed - "
6055 "Invalid Device Address\n",
6056 Controller, Channel, TargetID);
6057 break;
6058 case DAC960_V1_RebuildOrCheckAlreadyInProgress:
6059 DAC960_UserCritical("Rebuild of Physical Device %d:%d Failed - "
6060 "Rebuild or Consistency Check Already "
6061 "in Progress\n", Controller, Channel, TargetID);
6062 break;
6063 default:
6064 DAC960_UserCritical("Rebuild of Physical Device %d:%d Failed - "
6065 "Unexpected Status %04X\n", Controller,
6066 Channel, TargetID, Command->V1.CommandStatus);
6067 break;
6070 else if (strncmp(UserCommand, "check-consistency", 17) == 0 &&
6071 DAC960_ParseLogicalDrive(Controller, &UserCommand[17],
6072 &LogicalDriveNumber))
6074 CommandMailbox->Type3C.CommandOpcode = DAC960_V1_CheckConsistencyAsync;
6075 CommandMailbox->Type3C.LogicalDriveNumber = LogicalDriveNumber;
6076 CommandMailbox->Type3C.AutoRestore = true;
6077 DAC960_ExecuteCommand(Command);
6078 switch (Command->V1.CommandStatus)
6080 case DAC960_V1_NormalCompletion:
6081 DAC960_UserCritical("Consistency Check of Logical Drive %d "
6082 "(/dev/rd/c%dd%d) Initiated\n",
6083 Controller, LogicalDriveNumber,
6084 Controller->ControllerNumber,
6085 LogicalDriveNumber);
6086 break;
6087 case DAC960_V1_DependentDiskIsDead:
6088 DAC960_UserCritical("Consistency Check of Logical Drive %d "
6089 "(/dev/rd/c%dd%d) Failed - "
6090 "Dependent Physical Device is DEAD\n",
6091 Controller, LogicalDriveNumber,
6092 Controller->ControllerNumber,
6093 LogicalDriveNumber);
6094 break;
6095 case DAC960_V1_InvalidOrNonredundantLogicalDrive:
6096 DAC960_UserCritical("Consistency Check of Logical Drive %d "
6097 "(/dev/rd/c%dd%d) Failed - "
6098 "Invalid or Nonredundant Logical Drive\n",
6099 Controller, LogicalDriveNumber,
6100 Controller->ControllerNumber,
6101 LogicalDriveNumber);
6102 break;
6103 case DAC960_V1_RebuildOrCheckAlreadyInProgress:
6104 DAC960_UserCritical("Consistency Check of Logical Drive %d "
6105 "(/dev/rd/c%dd%d) Failed - Rebuild or "
6106 "Consistency Check Already in Progress\n",
6107 Controller, LogicalDriveNumber,
6108 Controller->ControllerNumber,
6109 LogicalDriveNumber);
6110 break;
6111 default:
6112 DAC960_UserCritical("Consistency Check of Logical Drive %d "
6113 "(/dev/rd/c%dd%d) Failed - "
6114 "Unexpected Status %04X\n",
6115 Controller, LogicalDriveNumber,
6116 Controller->ControllerNumber,
6117 LogicalDriveNumber, Command->V1.CommandStatus);
6118 break;
6121 else if (strcmp(UserCommand, "cancel-rebuild") == 0 ||
6122 strcmp(UserCommand, "cancel-consistency-check") == 0)
6124 /*
6125 the OldRebuildRateConstant is never actually used
6126 once its value is retrieved from the controller.
6127 */
6128 unsigned char *OldRebuildRateConstant;
6129 dma_addr_t OldRebuildRateConstantDMA;
6131 OldRebuildRateConstant = pci_alloc_consistent( Controller->PCIDevice,
6132 sizeof(char), &OldRebuildRateConstantDMA);
6133 if (OldRebuildRateConstant == NULL) {
6134 DAC960_UserCritical("Cancellation of Rebuild or "
6135 "Consistency Check Failed - "
6136 "Out of Memory",
6137 Controller);
6138 goto failure;
6140 CommandMailbox->Type3R.CommandOpcode = DAC960_V1_RebuildControl;
6141 CommandMailbox->Type3R.RebuildRateConstant = 0xFF;
6142 CommandMailbox->Type3R.BusAddress = OldRebuildRateConstantDMA;
6143 DAC960_ExecuteCommand(Command);
6144 switch (Command->V1.CommandStatus)
6146 case DAC960_V1_NormalCompletion:
6147 DAC960_UserCritical("Rebuild or Consistency Check Cancelled\n",
6148 Controller);
6149 break;
6150 default:
6151 DAC960_UserCritical("Cancellation of Rebuild or "
6152 "Consistency Check Failed - "
6153 "Unexpected Status %04X\n",
6154 Controller, Command->V1.CommandStatus);
6155 break;
6157 failure:
6158 pci_free_consistent(Controller->PCIDevice, sizeof(char),
6159 OldRebuildRateConstant, OldRebuildRateConstantDMA);
6161 else DAC960_UserCritical("Illegal User Command: '%s'\n",
6162 Controller, UserCommand);
6164 spin_lock_irqsave(&Controller->queue_lock, flags);
6165 DAC960_DeallocateCommand(Command);
6166 spin_unlock_irqrestore(&Controller->queue_lock, flags);
6167 return true;
6171 /*
6172 DAC960_V2_TranslatePhysicalDevice translates a Physical Device Channel and
6173 TargetID into a Logical Device. It returns true on success and false
6174 on failure.
6175 */
6177 static boolean DAC960_V2_TranslatePhysicalDevice(DAC960_Command_T *Command,
6178 unsigned char Channel,
6179 unsigned char TargetID,
6180 unsigned short
6181 *LogicalDeviceNumber)
6183 DAC960_V2_CommandMailbox_T SavedCommandMailbox, *CommandMailbox;
6184 DAC960_Controller_T *Controller = Command->Controller;
6186 CommandMailbox = &Command->V2.CommandMailbox;
6187 memcpy(&SavedCommandMailbox, CommandMailbox,
6188 sizeof(DAC960_V2_CommandMailbox_T));
6190 CommandMailbox->PhysicalDeviceInfo.CommandOpcode = DAC960_V2_IOCTL;
6191 CommandMailbox->PhysicalDeviceInfo.CommandControlBits
6192 .DataTransferControllerToHost = true;
6193 CommandMailbox->PhysicalDeviceInfo.CommandControlBits
6194 .NoAutoRequestSense = true;
6195 CommandMailbox->PhysicalDeviceInfo.DataTransferSize =
6196 sizeof(DAC960_V2_PhysicalToLogicalDevice_T);
6197 CommandMailbox->PhysicalDeviceInfo.PhysicalDevice.TargetID = TargetID;
6198 CommandMailbox->PhysicalDeviceInfo.PhysicalDevice.Channel = Channel;
6199 CommandMailbox->PhysicalDeviceInfo.IOCTL_Opcode =
6200 DAC960_V2_TranslatePhysicalToLogicalDevice;
6201 CommandMailbox->Common.DataTransferMemoryAddress
6202 .ScatterGatherSegments[0]
6203 .SegmentDataPointer =
6204 Controller->V2.PhysicalToLogicalDeviceDMA;
6205 CommandMailbox->Common.DataTransferMemoryAddress
6206 .ScatterGatherSegments[0]
6207 .SegmentByteCount =
6208 CommandMailbox->Common.DataTransferSize;
6210 DAC960_ExecuteCommand(Command);
6211 *LogicalDeviceNumber = Controller->V2.PhysicalToLogicalDevice->LogicalDeviceNumber;
6213 memcpy(CommandMailbox, &SavedCommandMailbox,
6214 sizeof(DAC960_V2_CommandMailbox_T));
6215 return (Command->V2.CommandStatus == DAC960_V2_NormalCompletion);
6219 /*
6220 DAC960_V2_ExecuteUserCommand executes a User Command for DAC960 V2 Firmware
6221 Controllers.
6222 */
6224 static boolean DAC960_V2_ExecuteUserCommand(DAC960_Controller_T *Controller,
6225 unsigned char *UserCommand)
6227 DAC960_Command_T *Command;
6228 DAC960_V2_CommandMailbox_T *CommandMailbox;
6229 unsigned long flags;
6230 unsigned char Channel, TargetID, LogicalDriveNumber;
6231 unsigned short LogicalDeviceNumber;
6233 spin_lock_irqsave(&Controller->queue_lock, flags);
6234 while ((Command = DAC960_AllocateCommand(Controller)) == NULL)
6235 DAC960_WaitForCommand(Controller);
6236 spin_unlock_irqrestore(&Controller->queue_lock, flags);
6237 Controller->UserStatusLength = 0;
6238 DAC960_V2_ClearCommand(Command);
6239 Command->CommandType = DAC960_ImmediateCommand;
6240 CommandMailbox = &Command->V2.CommandMailbox;
6241 CommandMailbox->Common.CommandOpcode = DAC960_V2_IOCTL;
6242 CommandMailbox->Common.CommandControlBits.DataTransferControllerToHost = true;
6243 CommandMailbox->Common.CommandControlBits.NoAutoRequestSense = true;
6244 if (strcmp(UserCommand, "flush-cache") == 0)
6246 CommandMailbox->DeviceOperation.IOCTL_Opcode = DAC960_V2_PauseDevice;
6247 CommandMailbox->DeviceOperation.OperationDevice =
6248 DAC960_V2_RAID_Controller;
6249 DAC960_ExecuteCommand(Command);
6250 DAC960_UserCritical("Cache Flush Completed\n", Controller);
6252 else if (strncmp(UserCommand, "kill", 4) == 0 &&
6253 DAC960_ParsePhysicalDevice(Controller, &UserCommand[4],
6254 &Channel, &TargetID) &&
6255 DAC960_V2_TranslatePhysicalDevice(Command, Channel, TargetID,
6256 &LogicalDeviceNumber))
6258 CommandMailbox->SetDeviceState.LogicalDevice.LogicalDeviceNumber =
6259 LogicalDeviceNumber;
6260 CommandMailbox->SetDeviceState.IOCTL_Opcode =
6261 DAC960_V2_SetDeviceState;
6262 CommandMailbox->SetDeviceState.DeviceState.PhysicalDeviceState =
6263 DAC960_V2_Device_Dead;
6264 DAC960_ExecuteCommand(Command);
6265 DAC960_UserCritical("Kill of Physical Device %d:%d %s\n",
6266 Controller, Channel, TargetID,
6267 (Command->V2.CommandStatus
6268 == DAC960_V2_NormalCompletion
6269 ? "Succeeded" : "Failed"));
6271 else if (strncmp(UserCommand, "make-online", 11) == 0 &&
6272 DAC960_ParsePhysicalDevice(Controller, &UserCommand[11],
6273 &Channel, &TargetID) &&
6274 DAC960_V2_TranslatePhysicalDevice(Command, Channel, TargetID,
6275 &LogicalDeviceNumber))
6277 CommandMailbox->SetDeviceState.LogicalDevice.LogicalDeviceNumber =
6278 LogicalDeviceNumber;
6279 CommandMailbox->SetDeviceState.IOCTL_Opcode =
6280 DAC960_V2_SetDeviceState;
6281 CommandMailbox->SetDeviceState.DeviceState.PhysicalDeviceState =
6282 DAC960_V2_Device_Online;
6283 DAC960_ExecuteCommand(Command);
6284 DAC960_UserCritical("Make Online of Physical Device %d:%d %s\n",
6285 Controller, Channel, TargetID,
6286 (Command->V2.CommandStatus
6287 == DAC960_V2_NormalCompletion
6288 ? "Succeeded" : "Failed"));
6290 else if (strncmp(UserCommand, "make-standby", 12) == 0 &&
6291 DAC960_ParsePhysicalDevice(Controller, &UserCommand[12],
6292 &Channel, &TargetID) &&
6293 DAC960_V2_TranslatePhysicalDevice(Command, Channel, TargetID,
6294 &LogicalDeviceNumber))
6296 CommandMailbox->SetDeviceState.LogicalDevice.LogicalDeviceNumber =
6297 LogicalDeviceNumber;
6298 CommandMailbox->SetDeviceState.IOCTL_Opcode =
6299 DAC960_V2_SetDeviceState;
6300 CommandMailbox->SetDeviceState.DeviceState.PhysicalDeviceState =
6301 DAC960_V2_Device_Standby;
6302 DAC960_ExecuteCommand(Command);
6303 DAC960_UserCritical("Make Standby of Physical Device %d:%d %s\n",
6304 Controller, Channel, TargetID,
6305 (Command->V2.CommandStatus
6306 == DAC960_V2_NormalCompletion
6307 ? "Succeeded" : "Failed"));
6309 else if (strncmp(UserCommand, "rebuild", 7) == 0 &&
6310 DAC960_ParsePhysicalDevice(Controller, &UserCommand[7],
6311 &Channel, &TargetID) &&
6312 DAC960_V2_TranslatePhysicalDevice(Command, Channel, TargetID,
6313 &LogicalDeviceNumber))
6315 CommandMailbox->LogicalDeviceInfo.LogicalDevice.LogicalDeviceNumber =
6316 LogicalDeviceNumber;
6317 CommandMailbox->LogicalDeviceInfo.IOCTL_Opcode =
6318 DAC960_V2_RebuildDeviceStart;
6319 DAC960_ExecuteCommand(Command);
6320 DAC960_UserCritical("Rebuild of Physical Device %d:%d %s\n",
6321 Controller, Channel, TargetID,
6322 (Command->V2.CommandStatus
6323 == DAC960_V2_NormalCompletion
6324 ? "Initiated" : "Not Initiated"));
6326 else if (strncmp(UserCommand, "cancel-rebuild", 14) == 0 &&
6327 DAC960_ParsePhysicalDevice(Controller, &UserCommand[14],
6328 &Channel, &TargetID) &&
6329 DAC960_V2_TranslatePhysicalDevice(Command, Channel, TargetID,
6330 &LogicalDeviceNumber))
6332 CommandMailbox->LogicalDeviceInfo.LogicalDevice.LogicalDeviceNumber =
6333 LogicalDeviceNumber;
6334 CommandMailbox->LogicalDeviceInfo.IOCTL_Opcode =
6335 DAC960_V2_RebuildDeviceStop;
6336 DAC960_ExecuteCommand(Command);
6337 DAC960_UserCritical("Rebuild of Physical Device %d:%d %s\n",
6338 Controller, Channel, TargetID,
6339 (Command->V2.CommandStatus
6340 == DAC960_V2_NormalCompletion
6341 ? "Cancelled" : "Not Cancelled"));
6343 else if (strncmp(UserCommand, "check-consistency", 17) == 0 &&
6344 DAC960_ParseLogicalDrive(Controller, &UserCommand[17],
6345 &LogicalDriveNumber))
6347 CommandMailbox->ConsistencyCheck.LogicalDevice.LogicalDeviceNumber =
6348 LogicalDriveNumber;
6349 CommandMailbox->ConsistencyCheck.IOCTL_Opcode =
6350 DAC960_V2_ConsistencyCheckStart;
6351 CommandMailbox->ConsistencyCheck.RestoreConsistency = true;
6352 CommandMailbox->ConsistencyCheck.InitializedAreaOnly = false;
6353 DAC960_ExecuteCommand(Command);
6354 DAC960_UserCritical("Consistency Check of Logical Drive %d "
6355 "(/dev/rd/c%dd%d) %s\n",
6356 Controller, LogicalDriveNumber,
6357 Controller->ControllerNumber,
6358 LogicalDriveNumber,
6359 (Command->V2.CommandStatus
6360 == DAC960_V2_NormalCompletion
6361 ? "Initiated" : "Not Initiated"));
6363 else if (strncmp(UserCommand, "cancel-consistency-check", 24) == 0 &&
6364 DAC960_ParseLogicalDrive(Controller, &UserCommand[24],
6365 &LogicalDriveNumber))
6367 CommandMailbox->ConsistencyCheck.LogicalDevice.LogicalDeviceNumber =
6368 LogicalDriveNumber;
6369 CommandMailbox->ConsistencyCheck.IOCTL_Opcode =
6370 DAC960_V2_ConsistencyCheckStop;
6371 DAC960_ExecuteCommand(Command);
6372 DAC960_UserCritical("Consistency Check of Logical Drive %d "
6373 "(/dev/rd/c%dd%d) %s\n",
6374 Controller, LogicalDriveNumber,
6375 Controller->ControllerNumber,
6376 LogicalDriveNumber,
6377 (Command->V2.CommandStatus
6378 == DAC960_V2_NormalCompletion
6379 ? "Cancelled" : "Not Cancelled"));
6381 else if (strcmp(UserCommand, "perform-discovery") == 0)
6383 CommandMailbox->Common.IOCTL_Opcode = DAC960_V2_StartDiscovery;
6384 DAC960_ExecuteCommand(Command);
6385 DAC960_UserCritical("Discovery %s\n", Controller,
6386 (Command->V2.CommandStatus
6387 == DAC960_V2_NormalCompletion
6388 ? "Initiated" : "Not Initiated"));
6389 if (Command->V2.CommandStatus == DAC960_V2_NormalCompletion)
6391 CommandMailbox->ControllerInfo.CommandOpcode = DAC960_V2_IOCTL;
6392 CommandMailbox->ControllerInfo.CommandControlBits
6393 .DataTransferControllerToHost = true;
6394 CommandMailbox->ControllerInfo.CommandControlBits
6395 .NoAutoRequestSense = true;
6396 CommandMailbox->ControllerInfo.DataTransferSize =
6397 sizeof(DAC960_V2_ControllerInfo_T);
6398 CommandMailbox->ControllerInfo.ControllerNumber = 0;
6399 CommandMailbox->ControllerInfo.IOCTL_Opcode =
6400 DAC960_V2_GetControllerInfo;
6401 /*
6402 * How does this NOT race with the queued Monitoring
6403 * usage of this structure?
6404 */
6405 CommandMailbox->ControllerInfo.DataTransferMemoryAddress
6406 .ScatterGatherSegments[0]
6407 .SegmentDataPointer =
6408 Controller->V2.NewControllerInformationDMA;
6409 CommandMailbox->ControllerInfo.DataTransferMemoryAddress
6410 .ScatterGatherSegments[0]
6411 .SegmentByteCount =
6412 CommandMailbox->ControllerInfo.DataTransferSize;
6413 DAC960_ExecuteCommand(Command);
6414 while (Controller->V2.NewControllerInformation->PhysicalScanActive)
6416 DAC960_ExecuteCommand(Command);
6417 sleep_on_timeout(&Controller->CommandWaitQueue, HZ);
6419 DAC960_UserCritical("Discovery Completed\n", Controller);
6422 else if (strcmp(UserCommand, "suppress-enclosure-messages") == 0)
6423 Controller->SuppressEnclosureMessages = true;
6424 else DAC960_UserCritical("Illegal User Command: '%s'\n",
6425 Controller, UserCommand);
6427 spin_lock_irqsave(&Controller->queue_lock, flags);
6428 DAC960_DeallocateCommand(Command);
6429 spin_unlock_irqrestore(&Controller->queue_lock, flags);
6430 return true;
6434 /*
6435 DAC960_ProcReadStatus implements reading /proc/rd/status.
6436 */
6438 static int DAC960_ProcReadStatus(char *Page, char **Start, off_t Offset,
6439 int Count, int *EOF, void *Data)
6441 unsigned char *StatusMessage = "OK\n";
6442 int ControllerNumber, BytesAvailable;
6443 for (ControllerNumber = 0;
6444 ControllerNumber < DAC960_ControllerCount;
6445 ControllerNumber++)
6447 DAC960_Controller_T *Controller = DAC960_Controllers[ControllerNumber];
6448 if (Controller == NULL) continue;
6449 if (Controller->MonitoringAlertMode)
6451 StatusMessage = "ALERT\n";
6452 break;
6455 BytesAvailable = strlen(StatusMessage) - Offset;
6456 if (Count >= BytesAvailable)
6458 Count = BytesAvailable;
6459 *EOF = true;
6461 if (Count <= 0) return 0;
6462 *Start = Page;
6463 memcpy(Page, &StatusMessage[Offset], Count);
6464 return Count;
6468 /*
6469 DAC960_ProcReadInitialStatus implements reading /proc/rd/cN/initial_status.
6470 */
6472 static int DAC960_ProcReadInitialStatus(char *Page, char **Start, off_t Offset,
6473 int Count, int *EOF, void *Data)
6475 DAC960_Controller_T *Controller = (DAC960_Controller_T *) Data;
6476 int BytesAvailable = Controller->InitialStatusLength - Offset;
6477 if (Count >= BytesAvailable)
6479 Count = BytesAvailable;
6480 *EOF = true;
6482 if (Count <= 0) return 0;
6483 *Start = Page;
6484 memcpy(Page, &Controller->CombinedStatusBuffer[Offset], Count);
6485 return Count;
6489 /*
6490 DAC960_ProcReadCurrentStatus implements reading /proc/rd/cN/current_status.
6491 */
6493 static int DAC960_ProcReadCurrentStatus(char *Page, char **Start, off_t Offset,
6494 int Count, int *EOF, void *Data)
6496 DAC960_Controller_T *Controller = (DAC960_Controller_T *) Data;
6497 unsigned char *StatusMessage =
6498 "No Rebuild or Consistency Check in Progress\n";
6499 int ProgressMessageLength = strlen(StatusMessage);
6500 int BytesAvailable;
6501 if (jiffies != Controller->LastCurrentStatusTime)
6503 Controller->CurrentStatusLength = 0;
6504 DAC960_AnnounceDriver(Controller);
6505 DAC960_ReportControllerConfiguration(Controller);
6506 DAC960_ReportDeviceConfiguration(Controller);
6507 if (Controller->ProgressBufferLength > 0)
6508 ProgressMessageLength = Controller->ProgressBufferLength;
6509 if (DAC960_CheckStatusBuffer(Controller, 2 + ProgressMessageLength))
6511 unsigned char *CurrentStatusBuffer = Controller->CurrentStatusBuffer;
6512 CurrentStatusBuffer[Controller->CurrentStatusLength++] = ' ';
6513 CurrentStatusBuffer[Controller->CurrentStatusLength++] = ' ';
6514 if (Controller->ProgressBufferLength > 0)
6515 strcpy(&CurrentStatusBuffer[Controller->CurrentStatusLength],
6516 Controller->ProgressBuffer);
6517 else
6518 strcpy(&CurrentStatusBuffer[Controller->CurrentStatusLength],
6519 StatusMessage);
6520 Controller->CurrentStatusLength += ProgressMessageLength;
6522 Controller->LastCurrentStatusTime = jiffies;
6524 BytesAvailable = Controller->CurrentStatusLength - Offset;
6525 if (Count >= BytesAvailable)
6527 Count = BytesAvailable;
6528 *EOF = true;
6530 if (Count <= 0) return 0;
6531 *Start = Page;
6532 memcpy(Page, &Controller->CurrentStatusBuffer[Offset], Count);
6533 return Count;
6537 /*
6538 DAC960_ProcReadUserCommand implements reading /proc/rd/cN/user_command.
6539 */
6541 static int DAC960_ProcReadUserCommand(char *Page, char **Start, off_t Offset,
6542 int Count, int *EOF, void *Data)
6544 DAC960_Controller_T *Controller = (DAC960_Controller_T *) Data;
6545 int BytesAvailable = Controller->UserStatusLength - Offset;
6546 if (Count >= BytesAvailable)
6548 Count = BytesAvailable;
6549 *EOF = true;
6551 if (Count <= 0) return 0;
6552 *Start = Page;
6553 memcpy(Page, &Controller->UserStatusBuffer[Offset], Count);
6554 return Count;
6558 /*
6559 DAC960_ProcWriteUserCommand implements writing /proc/rd/cN/user_command.
6560 */
6562 static int DAC960_ProcWriteUserCommand(struct file *file,
6563 const char __user *Buffer,
6564 unsigned long Count, void *Data)
6566 DAC960_Controller_T *Controller = (DAC960_Controller_T *) Data;
6567 unsigned char CommandBuffer[80];
6568 int Length;
6569 if (Count > sizeof(CommandBuffer)-1) return -EINVAL;
6570 if (copy_from_user(CommandBuffer, Buffer, Count)) return -EFAULT;
6571 CommandBuffer[Count] = '\0';
6572 Length = strlen(CommandBuffer);
6573 if (CommandBuffer[Length-1] == '\n')
6574 CommandBuffer[--Length] = '\0';
6575 if (Controller->FirmwareType == DAC960_V1_Controller)
6576 return (DAC960_V1_ExecuteUserCommand(Controller, CommandBuffer)
6577 ? Count : -EBUSY);
6578 else
6579 return (DAC960_V2_ExecuteUserCommand(Controller, CommandBuffer)
6580 ? Count : -EBUSY);
6584 /*
6585 DAC960_CreateProcEntries creates the /proc/rd/... entries for the
6586 DAC960 Driver.
6587 */
6589 static void DAC960_CreateProcEntries(DAC960_Controller_T *Controller)
6591 struct proc_dir_entry *StatusProcEntry;
6592 struct proc_dir_entry *ControllerProcEntry;
6593 struct proc_dir_entry *UserCommandProcEntry;
6595 if (DAC960_ProcDirectoryEntry == NULL) {
6596 DAC960_ProcDirectoryEntry = proc_mkdir("rd", NULL);
6597 StatusProcEntry = create_proc_read_entry("status", 0,
6598 DAC960_ProcDirectoryEntry,
6599 DAC960_ProcReadStatus, NULL);
6602 sprintf(Controller->ControllerName, "c%d", Controller->ControllerNumber);
6603 ControllerProcEntry = proc_mkdir(Controller->ControllerName,
6604 DAC960_ProcDirectoryEntry);
6605 create_proc_read_entry("initial_status", 0, ControllerProcEntry,
6606 DAC960_ProcReadInitialStatus, Controller);
6607 create_proc_read_entry("current_status", 0, ControllerProcEntry,
6608 DAC960_ProcReadCurrentStatus, Controller);
6609 UserCommandProcEntry =
6610 create_proc_read_entry("user_command", S_IWUSR | S_IRUSR,
6611 ControllerProcEntry, DAC960_ProcReadUserCommand,
6612 Controller);
6613 UserCommandProcEntry->write_proc = DAC960_ProcWriteUserCommand;
6614 Controller->ControllerProcEntry = ControllerProcEntry;
6618 /*
6619 DAC960_DestroyProcEntries destroys the /proc/rd/... entries for the
6620 DAC960 Driver.
6621 */
6623 static void DAC960_DestroyProcEntries(DAC960_Controller_T *Controller)
6625 if (Controller->ControllerProcEntry == NULL)
6626 return;
6627 remove_proc_entry("initial_status", Controller->ControllerProcEntry);
6628 remove_proc_entry("current_status", Controller->ControllerProcEntry);
6629 remove_proc_entry("user_command", Controller->ControllerProcEntry);
6630 remove_proc_entry(Controller->ControllerName, DAC960_ProcDirectoryEntry);
6631 Controller->ControllerProcEntry = NULL;
6634 #ifdef DAC960_GAM_MINOR
6636 /*
6637 * DAC960_gam_ioctl is the ioctl function for performing RAID operations.
6638 */
6640 static int DAC960_gam_ioctl(struct inode *inode, struct file *file,
6641 unsigned int Request, unsigned long Argument)
6643 int ErrorCode = 0;
6644 if (!capable(CAP_SYS_ADMIN)) return -EACCES;
6645 switch (Request)
6647 case DAC960_IOCTL_GET_CONTROLLER_COUNT:
6648 return DAC960_ControllerCount;
6649 case DAC960_IOCTL_GET_CONTROLLER_INFO:
6651 DAC960_ControllerInfo_T __user *UserSpaceControllerInfo =
6652 (DAC960_ControllerInfo_T __user *) Argument;
6653 DAC960_ControllerInfo_T ControllerInfo;
6654 DAC960_Controller_T *Controller;
6655 int ControllerNumber;
6656 if (UserSpaceControllerInfo == NULL) return -EINVAL;
6657 ErrorCode = get_user(ControllerNumber,
6658 &UserSpaceControllerInfo->ControllerNumber);
6659 if (ErrorCode != 0) return ErrorCode;
6660 if (ControllerNumber < 0 ||
6661 ControllerNumber > DAC960_ControllerCount - 1)
6662 return -ENXIO;
6663 Controller = DAC960_Controllers[ControllerNumber];
6664 if (Controller == NULL) return -ENXIO;
6665 memset(&ControllerInfo, 0, sizeof(DAC960_ControllerInfo_T));
6666 ControllerInfo.ControllerNumber = ControllerNumber;
6667 ControllerInfo.FirmwareType = Controller->FirmwareType;
6668 ControllerInfo.Channels = Controller->Channels;
6669 ControllerInfo.Targets = Controller->Targets;
6670 ControllerInfo.PCI_Bus = Controller->Bus;
6671 ControllerInfo.PCI_Device = Controller->Device;
6672 ControllerInfo.PCI_Function = Controller->Function;
6673 ControllerInfo.IRQ_Channel = Controller->IRQ_Channel;
6674 ControllerInfo.PCI_Address = Controller->PCI_Address;
6675 strcpy(ControllerInfo.ModelName, Controller->ModelName);
6676 strcpy(ControllerInfo.FirmwareVersion, Controller->FirmwareVersion);
6677 return (copy_to_user(UserSpaceControllerInfo, &ControllerInfo,
6678 sizeof(DAC960_ControllerInfo_T)) ? -EFAULT : 0);
6680 case DAC960_IOCTL_V1_EXECUTE_COMMAND:
6682 DAC960_V1_UserCommand_T __user *UserSpaceUserCommand =
6683 (DAC960_V1_UserCommand_T __user *) Argument;
6684 DAC960_V1_UserCommand_T UserCommand;
6685 DAC960_Controller_T *Controller;
6686 DAC960_Command_T *Command = NULL;
6687 DAC960_V1_CommandOpcode_T CommandOpcode;
6688 DAC960_V1_CommandStatus_T CommandStatus;
6689 DAC960_V1_DCDB_T DCDB;
6690 DAC960_V1_DCDB_T *DCDB_IOBUF = NULL;
6691 dma_addr_t DCDB_IOBUFDMA;
6692 unsigned long flags;
6693 int ControllerNumber, DataTransferLength;
6694 unsigned char *DataTransferBuffer = NULL;
6695 dma_addr_t DataTransferBufferDMA;
6696 if (UserSpaceUserCommand == NULL) return -EINVAL;
6697 if (copy_from_user(&UserCommand, UserSpaceUserCommand,
6698 sizeof(DAC960_V1_UserCommand_T))) {
6699 ErrorCode = -EFAULT;
6700 goto Failure1a;
6702 ControllerNumber = UserCommand.ControllerNumber;
6703 if (ControllerNumber < 0 ||
6704 ControllerNumber > DAC960_ControllerCount - 1)
6705 return -ENXIO;
6706 Controller = DAC960_Controllers[ControllerNumber];
6707 if (Controller == NULL) return -ENXIO;
6708 if (Controller->FirmwareType != DAC960_V1_Controller) return -EINVAL;
6709 CommandOpcode = UserCommand.CommandMailbox.Common.CommandOpcode;
6710 DataTransferLength = UserCommand.DataTransferLength;
6711 if (CommandOpcode & 0x80) return -EINVAL;
6712 if (CommandOpcode == DAC960_V1_DCDB)
6714 if (copy_from_user(&DCDB, UserCommand.DCDB,
6715 sizeof(DAC960_V1_DCDB_T))) {
6716 ErrorCode = -EFAULT;
6717 goto Failure1a;
6719 if (DCDB.Channel >= DAC960_V1_MaxChannels) return -EINVAL;
6720 if (!((DataTransferLength == 0 &&
6721 DCDB.Direction
6722 == DAC960_V1_DCDB_NoDataTransfer) ||
6723 (DataTransferLength > 0 &&
6724 DCDB.Direction
6725 == DAC960_V1_DCDB_DataTransferDeviceToSystem) ||
6726 (DataTransferLength < 0 &&
6727 DCDB.Direction
6728 == DAC960_V1_DCDB_DataTransferSystemToDevice)))
6729 return -EINVAL;
6730 if (((DCDB.TransferLengthHigh4 << 16) | DCDB.TransferLength)
6731 != abs(DataTransferLength))
6732 return -EINVAL;
6733 DCDB_IOBUF = pci_alloc_consistent(Controller->PCIDevice,
6734 sizeof(DAC960_V1_DCDB_T), &DCDB_IOBUFDMA);
6735 if (DCDB_IOBUF == NULL)
6736 return -ENOMEM;
6738 if (DataTransferLength > 0)
6740 DataTransferBuffer = pci_alloc_consistent(Controller->PCIDevice,
6741 DataTransferLength, &DataTransferBufferDMA);
6742 if (DataTransferBuffer == NULL) {
6743 ErrorCode = -ENOMEM;
6744 goto Failure1;
6746 memset(DataTransferBuffer, 0, DataTransferLength);
6748 else if (DataTransferLength < 0)
6750 DataTransferBuffer = pci_alloc_consistent(Controller->PCIDevice,
6751 -DataTransferLength, &DataTransferBufferDMA);
6752 if (DataTransferBuffer == NULL) {
6753 ErrorCode = -ENOMEM;
6754 goto Failure1;
6756 if (copy_from_user(DataTransferBuffer,
6757 UserCommand.DataTransferBuffer,
6758 -DataTransferLength)) {
6759 ErrorCode = -EFAULT;
6760 goto Failure1;
6763 if (CommandOpcode == DAC960_V1_DCDB)
6765 spin_lock_irqsave(&Controller->queue_lock, flags);
6766 while ((Command = DAC960_AllocateCommand(Controller)) == NULL)
6767 DAC960_WaitForCommand(Controller);
6768 while (Controller->V1.DirectCommandActive[DCDB.Channel]
6769 [DCDB.TargetID])
6771 spin_unlock_irq(&Controller->queue_lock);
6772 __wait_event(Controller->CommandWaitQueue,
6773 !Controller->V1.DirectCommandActive
6774 [DCDB.Channel][DCDB.TargetID]);
6775 spin_lock_irq(&Controller->queue_lock);
6777 Controller->V1.DirectCommandActive[DCDB.Channel]
6778 [DCDB.TargetID] = true;
6779 spin_unlock_irqrestore(&Controller->queue_lock, flags);
6780 DAC960_V1_ClearCommand(Command);
6781 Command->CommandType = DAC960_ImmediateCommand;
6782 memcpy(&Command->V1.CommandMailbox, &UserCommand.CommandMailbox,
6783 sizeof(DAC960_V1_CommandMailbox_T));
6784 Command->V1.CommandMailbox.Type3.BusAddress = DCDB_IOBUFDMA;
6785 DCDB.BusAddress = DataTransferBufferDMA;
6786 memcpy(DCDB_IOBUF, &DCDB, sizeof(DAC960_V1_DCDB_T));
6788 else
6790 spin_lock_irqsave(&Controller->queue_lock, flags);
6791 while ((Command = DAC960_AllocateCommand(Controller)) == NULL)
6792 DAC960_WaitForCommand(Controller);
6793 spin_unlock_irqrestore(&Controller->queue_lock, flags);
6794 DAC960_V1_ClearCommand(Command);
6795 Command->CommandType = DAC960_ImmediateCommand;
6796 memcpy(&Command->V1.CommandMailbox, &UserCommand.CommandMailbox,
6797 sizeof(DAC960_V1_CommandMailbox_T));
6798 if (DataTransferBuffer != NULL)
6799 Command->V1.CommandMailbox.Type3.BusAddress =
6800 DataTransferBufferDMA;
6802 DAC960_ExecuteCommand(Command);
6803 CommandStatus = Command->V1.CommandStatus;
6804 spin_lock_irqsave(&Controller->queue_lock, flags);
6805 DAC960_DeallocateCommand(Command);
6806 spin_unlock_irqrestore(&Controller->queue_lock, flags);
6807 if (DataTransferLength > 0)
6809 if (copy_to_user(UserCommand.DataTransferBuffer,
6810 DataTransferBuffer, DataTransferLength)) {
6811 ErrorCode = -EFAULT;
6812 goto Failure1;
6815 if (CommandOpcode == DAC960_V1_DCDB)
6817 /*
6818 I don't believe Target or Channel in the DCDB_IOBUF
6819 should be any different from the contents of DCDB.
6820 */
6821 Controller->V1.DirectCommandActive[DCDB.Channel]
6822 [DCDB.TargetID] = false;
6823 if (copy_to_user(UserCommand.DCDB, DCDB_IOBUF,
6824 sizeof(DAC960_V1_DCDB_T))) {
6825 ErrorCode = -EFAULT;
6826 goto Failure1;
6829 ErrorCode = CommandStatus;
6830 Failure1:
6831 if (DataTransferBuffer != NULL)
6832 pci_free_consistent(Controller->PCIDevice, abs(DataTransferLength),
6833 DataTransferBuffer, DataTransferBufferDMA);
6834 if (DCDB_IOBUF != NULL)
6835 pci_free_consistent(Controller->PCIDevice, sizeof(DAC960_V1_DCDB_T),
6836 DCDB_IOBUF, DCDB_IOBUFDMA);
6837 Failure1a:
6838 return ErrorCode;
6840 case DAC960_IOCTL_V2_EXECUTE_COMMAND:
6842 DAC960_V2_UserCommand_T __user *UserSpaceUserCommand =
6843 (DAC960_V2_UserCommand_T __user *) Argument;
6844 DAC960_V2_UserCommand_T UserCommand;
6845 DAC960_Controller_T *Controller;
6846 DAC960_Command_T *Command = NULL;
6847 DAC960_V2_CommandMailbox_T *CommandMailbox;
6848 DAC960_V2_CommandStatus_T CommandStatus;
6849 unsigned long flags;
6850 int ControllerNumber, DataTransferLength;
6851 int DataTransferResidue, RequestSenseLength;
6852 unsigned char *DataTransferBuffer = NULL;
6853 dma_addr_t DataTransferBufferDMA;
6854 unsigned char *RequestSenseBuffer = NULL;
6855 dma_addr_t RequestSenseBufferDMA;
6856 if (UserSpaceUserCommand == NULL) return -EINVAL;
6857 if (copy_from_user(&UserCommand, UserSpaceUserCommand,
6858 sizeof(DAC960_V2_UserCommand_T))) {
6859 ErrorCode = -EFAULT;
6860 goto Failure2a;
6862 ControllerNumber = UserCommand.ControllerNumber;
6863 if (ControllerNumber < 0 ||
6864 ControllerNumber > DAC960_ControllerCount - 1)
6865 return -ENXIO;
6866 Controller = DAC960_Controllers[ControllerNumber];
6867 if (Controller == NULL) return -ENXIO;
6868 if (Controller->FirmwareType != DAC960_V2_Controller) return -EINVAL;
6869 DataTransferLength = UserCommand.DataTransferLength;
6870 if (DataTransferLength > 0)
6872 DataTransferBuffer = pci_alloc_consistent(Controller->PCIDevice,
6873 DataTransferLength, &DataTransferBufferDMA);
6874 if (DataTransferBuffer == NULL) return -ENOMEM;
6875 memset(DataTransferBuffer, 0, DataTransferLength);
6877 else if (DataTransferLength < 0)
6879 DataTransferBuffer = pci_alloc_consistent(Controller->PCIDevice,
6880 -DataTransferLength, &DataTransferBufferDMA);
6881 if (DataTransferBuffer == NULL) return -ENOMEM;
6882 if (copy_from_user(DataTransferBuffer,
6883 UserCommand.DataTransferBuffer,
6884 -DataTransferLength)) {
6885 ErrorCode = -EFAULT;
6886 goto Failure2;
6889 RequestSenseLength = UserCommand.RequestSenseLength;
6890 if (RequestSenseLength > 0)
6892 RequestSenseBuffer = pci_alloc_consistent(Controller->PCIDevice,
6893 RequestSenseLength, &RequestSenseBufferDMA);
6894 if (RequestSenseBuffer == NULL)
6896 ErrorCode = -ENOMEM;
6897 goto Failure2;
6899 memset(RequestSenseBuffer, 0, RequestSenseLength);
6901 spin_lock_irqsave(&Controller->queue_lock, flags);
6902 while ((Command = DAC960_AllocateCommand(Controller)) == NULL)
6903 DAC960_WaitForCommand(Controller);
6904 spin_unlock_irqrestore(&Controller->queue_lock, flags);
6905 DAC960_V2_ClearCommand(Command);
6906 Command->CommandType = DAC960_ImmediateCommand;
6907 CommandMailbox = &Command->V2.CommandMailbox;
6908 memcpy(CommandMailbox, &UserCommand.CommandMailbox,
6909 sizeof(DAC960_V2_CommandMailbox_T));
6910 CommandMailbox->Common.CommandControlBits
6911 .AdditionalScatterGatherListMemory = false;
6912 CommandMailbox->Common.CommandControlBits
6913 .NoAutoRequestSense = true;
6914 CommandMailbox->Common.DataTransferSize = 0;
6915 CommandMailbox->Common.DataTransferPageNumber = 0;
6916 memset(&CommandMailbox->Common.DataTransferMemoryAddress, 0,
6917 sizeof(DAC960_V2_DataTransferMemoryAddress_T));
6918 if (DataTransferLength != 0)
6920 if (DataTransferLength > 0)
6922 CommandMailbox->Common.CommandControlBits
6923 .DataTransferControllerToHost = true;
6924 CommandMailbox->Common.DataTransferSize = DataTransferLength;
6926 else
6928 CommandMailbox->Common.CommandControlBits
6929 .DataTransferControllerToHost = false;
6930 CommandMailbox->Common.DataTransferSize = -DataTransferLength;
6932 CommandMailbox->Common.DataTransferMemoryAddress
6933 .ScatterGatherSegments[0]
6934 .SegmentDataPointer = DataTransferBufferDMA;
6935 CommandMailbox->Common.DataTransferMemoryAddress
6936 .ScatterGatherSegments[0]
6937 .SegmentByteCount =
6938 CommandMailbox->Common.DataTransferSize;
6940 if (RequestSenseLength > 0)
6942 CommandMailbox->Common.CommandControlBits
6943 .NoAutoRequestSense = false;
6944 CommandMailbox->Common.RequestSenseSize = RequestSenseLength;
6945 CommandMailbox->Common.RequestSenseBusAddress =
6946 RequestSenseBufferDMA;
6948 DAC960_ExecuteCommand(Command);
6949 CommandStatus = Command->V2.CommandStatus;
6950 RequestSenseLength = Command->V2.RequestSenseLength;
6951 DataTransferResidue = Command->V2.DataTransferResidue;
6952 spin_lock_irqsave(&Controller->queue_lock, flags);
6953 DAC960_DeallocateCommand(Command);
6954 spin_unlock_irqrestore(&Controller->queue_lock, flags);
6955 if (RequestSenseLength > UserCommand.RequestSenseLength)
6956 RequestSenseLength = UserCommand.RequestSenseLength;
6957 if (copy_to_user(&UserSpaceUserCommand->DataTransferLength,
6958 &DataTransferResidue,
6959 sizeof(DataTransferResidue))) {
6960 ErrorCode = -EFAULT;
6961 goto Failure2;
6963 if (copy_to_user(&UserSpaceUserCommand->RequestSenseLength,
6964 &RequestSenseLength, sizeof(RequestSenseLength))) {
6965 ErrorCode = -EFAULT;
6966 goto Failure2;
6968 if (DataTransferLength > 0)
6970 if (copy_to_user(UserCommand.DataTransferBuffer,
6971 DataTransferBuffer, DataTransferLength)) {
6972 ErrorCode = -EFAULT;
6973 goto Failure2;
6976 if (RequestSenseLength > 0)
6978 if (copy_to_user(UserCommand.RequestSenseBuffer,
6979 RequestSenseBuffer, RequestSenseLength)) {
6980 ErrorCode = -EFAULT;
6981 goto Failure2;
6984 ErrorCode = CommandStatus;
6985 Failure2:
6986 pci_free_consistent(Controller->PCIDevice, abs(DataTransferLength),
6987 DataTransferBuffer, DataTransferBufferDMA);
6988 if (RequestSenseBuffer != NULL)
6989 pci_free_consistent(Controller->PCIDevice, RequestSenseLength,
6990 RequestSenseBuffer, RequestSenseBufferDMA);
6991 Failure2a:
6992 return ErrorCode;
6994 case DAC960_IOCTL_V2_GET_HEALTH_STATUS:
6996 DAC960_V2_GetHealthStatus_T __user *UserSpaceGetHealthStatus =
6997 (DAC960_V2_GetHealthStatus_T __user *) Argument;
6998 DAC960_V2_GetHealthStatus_T GetHealthStatus;
6999 DAC960_V2_HealthStatusBuffer_T HealthStatusBuffer;
7000 DAC960_Controller_T *Controller;
7001 int ControllerNumber;
7002 if (UserSpaceGetHealthStatus == NULL) return -EINVAL;
7003 if (copy_from_user(&GetHealthStatus, UserSpaceGetHealthStatus,
7004 sizeof(DAC960_V2_GetHealthStatus_T)))
7005 return -EFAULT;
7006 ControllerNumber = GetHealthStatus.ControllerNumber;
7007 if (ControllerNumber < 0 ||
7008 ControllerNumber > DAC960_ControllerCount - 1)
7009 return -ENXIO;
7010 Controller = DAC960_Controllers[ControllerNumber];
7011 if (Controller == NULL) return -ENXIO;
7012 if (Controller->FirmwareType != DAC960_V2_Controller) return -EINVAL;
7013 if (copy_from_user(&HealthStatusBuffer,
7014 GetHealthStatus.HealthStatusBuffer,
7015 sizeof(DAC960_V2_HealthStatusBuffer_T)))
7016 return -EFAULT;
7017 while (Controller->V2.HealthStatusBuffer->StatusChangeCounter
7018 == HealthStatusBuffer.StatusChangeCounter &&
7019 Controller->V2.HealthStatusBuffer->NextEventSequenceNumber
7020 == HealthStatusBuffer.NextEventSequenceNumber)
7022 interruptible_sleep_on_timeout(&Controller->HealthStatusWaitQueue,
7023 DAC960_MonitoringTimerInterval);
7024 if (signal_pending(current)) return -EINTR;
7026 if (copy_to_user(GetHealthStatus.HealthStatusBuffer,
7027 Controller->V2.HealthStatusBuffer,
7028 sizeof(DAC960_V2_HealthStatusBuffer_T)))
7029 return -EFAULT;
7030 return 0;
7033 return -EINVAL;
7036 static struct file_operations DAC960_gam_fops = {
7037 .owner = THIS_MODULE,
7038 .ioctl = DAC960_gam_ioctl
7039 };
7041 static struct miscdevice DAC960_gam_dev = {
7042 DAC960_GAM_MINOR,
7043 "dac960_gam",
7044 &DAC960_gam_fops
7045 };
7047 static int DAC960_gam_init(void)
7049 int ret;
7051 ret = misc_register(&DAC960_gam_dev);
7052 if (ret)
7053 printk(KERN_ERR "DAC960_gam: can't misc_register on minor %d\n", DAC960_GAM_MINOR);
7054 return ret;
7057 static void DAC960_gam_cleanup(void)
7059 misc_deregister(&DAC960_gam_dev);
7062 #endif /* DAC960_GAM_MINOR */
7064 static struct DAC960_privdata DAC960_GEM_privdata = {
7065 .HardwareType = DAC960_GEM_Controller,
7066 .FirmwareType = DAC960_V2_Controller,
7067 .InterruptHandler = DAC960_GEM_InterruptHandler,
7068 .MemoryWindowSize = DAC960_GEM_RegisterWindowSize,
7069 };
7072 static struct DAC960_privdata DAC960_BA_privdata = {
7073 .HardwareType = DAC960_BA_Controller,
7074 .FirmwareType = DAC960_V2_Controller,
7075 .InterruptHandler = DAC960_BA_InterruptHandler,
7076 .MemoryWindowSize = DAC960_BA_RegisterWindowSize,
7077 };
7079 static struct DAC960_privdata DAC960_LP_privdata = {
7080 .HardwareType = DAC960_LP_Controller,
7081 .FirmwareType = DAC960_LP_Controller,
7082 .InterruptHandler = DAC960_LP_InterruptHandler,
7083 .MemoryWindowSize = DAC960_LP_RegisterWindowSize,
7084 };
7086 static struct DAC960_privdata DAC960_LA_privdata = {
7087 .HardwareType = DAC960_LA_Controller,
7088 .FirmwareType = DAC960_V1_Controller,
7089 .InterruptHandler = DAC960_LA_InterruptHandler,
7090 .MemoryWindowSize = DAC960_LA_RegisterWindowSize,
7091 };
7093 static struct DAC960_privdata DAC960_PG_privdata = {
7094 .HardwareType = DAC960_PG_Controller,
7095 .FirmwareType = DAC960_V1_Controller,
7096 .InterruptHandler = DAC960_PG_InterruptHandler,
7097 .MemoryWindowSize = DAC960_PG_RegisterWindowSize,
7098 };
7100 static struct DAC960_privdata DAC960_PD_privdata = {
7101 .HardwareType = DAC960_PD_Controller,
7102 .FirmwareType = DAC960_V1_Controller,
7103 .InterruptHandler = DAC960_PD_InterruptHandler,
7104 .MemoryWindowSize = DAC960_PD_RegisterWindowSize,
7105 };
7107 static struct DAC960_privdata DAC960_P_privdata = {
7108 .HardwareType = DAC960_P_Controller,
7109 .FirmwareType = DAC960_V1_Controller,
7110 .InterruptHandler = DAC960_P_InterruptHandler,
7111 .MemoryWindowSize = DAC960_PD_RegisterWindowSize,
7112 };
7114 static struct pci_device_id DAC960_id_table[] = {
7116 .vendor = PCI_VENDOR_ID_MYLEX,
7117 .device = PCI_DEVICE_ID_MYLEX_DAC960_GEM,
7118 .subvendor = PCI_VENDOR_ID_MYLEX,
7119 .subdevice = PCI_ANY_ID,
7120 .driver_data = (unsigned long) &DAC960_GEM_privdata,
7121 },
7123 .vendor = PCI_VENDOR_ID_MYLEX,
7124 .device = PCI_DEVICE_ID_MYLEX_DAC960_BA,
7125 .subvendor = PCI_ANY_ID,
7126 .subdevice = PCI_ANY_ID,
7127 .driver_data = (unsigned long) &DAC960_BA_privdata,
7128 },
7130 .vendor = PCI_VENDOR_ID_MYLEX,
7131 .device = PCI_DEVICE_ID_MYLEX_DAC960_LP,
7132 .subvendor = PCI_ANY_ID,
7133 .subdevice = PCI_ANY_ID,
7134 .driver_data = (unsigned long) &DAC960_LP_privdata,
7135 },
7137 .vendor = PCI_VENDOR_ID_DEC,
7138 .device = PCI_DEVICE_ID_DEC_21285,
7139 .subvendor = PCI_VENDOR_ID_MYLEX,
7140 .subdevice = PCI_DEVICE_ID_MYLEX_DAC960_LA,
7141 .driver_data = (unsigned long) &DAC960_LA_privdata,
7142 },
7144 .vendor = PCI_VENDOR_ID_MYLEX,
7145 .device = PCI_DEVICE_ID_MYLEX_DAC960_PG,
7146 .subvendor = PCI_ANY_ID,
7147 .subdevice = PCI_ANY_ID,
7148 .driver_data = (unsigned long) &DAC960_PG_privdata,
7149 },
7151 .vendor = PCI_VENDOR_ID_MYLEX,
7152 .device = PCI_DEVICE_ID_MYLEX_DAC960_PD,
7153 .subvendor = PCI_ANY_ID,
7154 .subdevice = PCI_ANY_ID,
7155 .driver_data = (unsigned long) &DAC960_PD_privdata,
7156 },
7158 .vendor = PCI_VENDOR_ID_MYLEX,
7159 .device = PCI_DEVICE_ID_MYLEX_DAC960_P,
7160 .subvendor = PCI_ANY_ID,
7161 .subdevice = PCI_ANY_ID,
7162 .driver_data = (unsigned long) &DAC960_P_privdata,
7163 },
7164 {0, },
7165 };
7167 MODULE_DEVICE_TABLE(pci, DAC960_id_table);
7169 static struct pci_driver DAC960_pci_driver = {
7170 .name = "DAC960",
7171 .id_table = DAC960_id_table,
7172 .probe = DAC960_Probe,
7173 .remove = DAC960_Remove,
7174 };
7176 static int DAC960_init_module(void)
7178 int ret;
7180 ret = pci_register_driver(&DAC960_pci_driver);
7181 #ifdef DAC960_GAM_MINOR
7182 if (!ret)
7183 DAC960_gam_init();
7184 #endif
7185 return ret;
7188 static void DAC960_cleanup_module(void)
7190 int i;
7192 #ifdef DAC960_GAM_MINOR
7193 DAC960_gam_cleanup();
7194 #endif
7196 for (i = 0; i < DAC960_ControllerCount; i++) {
7197 DAC960_Controller_T *Controller = DAC960_Controllers[i];
7198 if (Controller == NULL)
7199 continue;
7200 DAC960_FinalizeController(Controller);
7202 if (DAC960_ProcDirectoryEntry != NULL) {
7203 remove_proc_entry("rd/status", NULL);
7204 remove_proc_entry("rd", NULL);
7206 DAC960_ControllerCount = 0;
7207 pci_unregister_driver(&DAC960_pci_driver);
7210 module_init(DAC960_init_module);
7211 module_exit(DAC960_cleanup_module);
7213 MODULE_LICENSE("GPL");