开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
DAC960.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：257k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

DAC960.c：源码内容
  1.       DAC960_AnnounceDriver(Controller);
  2.       Controller->FirmwareType = FirmwareType;
  3.       Controller->HardwareType = HardwareType;
  4.       Controller->IO_Address = IO_Address;
  5.       Controller->PCI_Address = PCI_Address;
  6.       Controller->Bus = Bus;
  7.       Controller->Device = Device;
  8.       Controller->Function = Function;
  9.       /*
  10. Map the Controller Register Window.
  11.       */
  12.       if (MemoryWindowSize < PAGE_SIZE)
  13. MemoryWindowSize = PAGE_SIZE;
  14.       Controller->MemoryMappedAddress =
  15. ioremap_nocache(PCI_Address & PAGE_MASK, MemoryWindowSize);
  16.       Controller->BaseAddress =
  17. Controller->MemoryMappedAddress + (PCI_Address & ~PAGE_MASK);
  18.       if (Controller->MemoryMappedAddress == NULL)
  19. {
  20.   DAC960_Error("Unable to map Controller Register Window for "
  21.        "Controller atn", Controller);
  22.   goto Failure;
  23. }
  24.       BaseAddress = Controller->BaseAddress;
  25.       switch (HardwareType)
  26. {
  27. case DAC960_BA_Controller:
  28.   DAC960_BA_DisableInterrupts(Controller->BaseAddress);
  29.   DAC960_BA_AcknowledgeHardwareMailboxStatus(BaseAddress);
  30.   udelay(1000);
  31.   while (DAC960_BA_InitializationInProgressP(BaseAddress))
  32.     {
  33.       if (DAC960_BA_ReadErrorStatus(BaseAddress, &ErrorStatus,
  34.     &Parameter0, &Parameter1) &&
  35.   DAC960_ReportErrorStatus(Controller, ErrorStatus,
  36.    Parameter0, Parameter1))
  37. goto Failure;
  38.       udelay(10);
  39.     }
  40.   if (!DAC960_V2_EnableMemoryMailboxInterface(Controller))
  41.     {
  42.       DAC960_Error("Unable to Enable Memory Mailbox Interface "
  43.    "for Controller atn", Controller);
  44.       goto Failure;
  45.     }
  46.   DAC960_BA_EnableInterrupts(Controller->BaseAddress);
  47.   Controller->QueueCommand = DAC960_BA_QueueCommand;
  48.   Controller->ReadControllerConfiguration =
  49.     DAC960_V2_ReadControllerConfiguration;
  50.   Controller->ReadDeviceConfiguration =
  51.     DAC960_V2_ReadDeviceConfiguration;
  52.   Controller->ReportDeviceConfiguration =
  53.     DAC960_V2_ReportDeviceConfiguration;
  54.   Controller->QueueReadWriteCommand =
  55.     DAC960_V2_QueueReadWriteCommand;
  56.   break;
  57. case DAC960_LP_Controller:
  58.   DAC960_LP_DisableInterrupts(Controller->BaseAddress);
  59.   DAC960_LP_AcknowledgeHardwareMailboxStatus(BaseAddress);
  60.   udelay(1000);
  61.   while (DAC960_LP_InitializationInProgressP(BaseAddress))
  62.     {
  63.       if (DAC960_LP_ReadErrorStatus(BaseAddress, &ErrorStatus,
  64.     &Parameter0, &Parameter1) &&
  65.   DAC960_ReportErrorStatus(Controller, ErrorStatus,
  66.    Parameter0, Parameter1))
  67. goto Failure;
  68.       udelay(10);
  69.     }
  70.   if (!DAC960_V2_EnableMemoryMailboxInterface(Controller))
  71.     {
  72.       DAC960_Error("Unable to Enable Memory Mailbox Interface "
  73.    "for Controller atn", Controller);
  74.       goto Failure;
  75.     }
  76.   DAC960_LP_EnableInterrupts(Controller->BaseAddress);
  77.   Controller->QueueCommand = DAC960_LP_QueueCommand;
  78.   Controller->ReadControllerConfiguration =
  79.     DAC960_V2_ReadControllerConfiguration;
  80.   Controller->ReadDeviceConfiguration =
  81.     DAC960_V2_ReadDeviceConfiguration;
  82.   Controller->ReportDeviceConfiguration =
  83.     DAC960_V2_ReportDeviceConfiguration;
  84.   Controller->QueueReadWriteCommand =
  85.     DAC960_V2_QueueReadWriteCommand;
  86.   break;
  87. case DAC960_LA_Controller:
  88.   DAC960_LA_DisableInterrupts(Controller->BaseAddress);
  89.   DAC960_LA_AcknowledgeHardwareMailboxStatus(BaseAddress);
  90.   udelay(1000);
  91.   while (DAC960_LA_InitializationInProgressP(BaseAddress))
  92.     {
  93.       if (DAC960_LA_ReadErrorStatus(BaseAddress, &ErrorStatus,
  94.     &Parameter0, &Parameter1) &&
  95.   DAC960_ReportErrorStatus(Controller, ErrorStatus,
  96.    Parameter0, Parameter1))
  97. goto Failure;
  98.       udelay(10);
  99.     }
  100.   if (!DAC960_V1_EnableMemoryMailboxInterface(Controller))
  101.     {
  102.       DAC960_Error("Unable to Enable Memory Mailbox Interface "
  103.    "for Controller atn", Controller);
  104.       goto Failure;
  105.     }
  106.   DAC960_LA_EnableInterrupts(Controller->BaseAddress);
  107.   if (Controller->V1.DualModeMemoryMailboxInterface)
  108.     Controller->QueueCommand = DAC960_LA_QueueCommandDualMode;
  109.   else Controller->QueueCommand = DAC960_LA_QueueCommandSingleMode;
  110.   Controller->ReadControllerConfiguration =
  111.     DAC960_V1_ReadControllerConfiguration;
  112.   Controller->ReadDeviceConfiguration =
  113.     DAC960_V1_ReadDeviceConfiguration;
  114.   Controller->ReportDeviceConfiguration =
  115.     DAC960_V1_ReportDeviceConfiguration;
  116.   Controller->QueueReadWriteCommand =
  117.     DAC960_V1_QueueReadWriteCommand;
  118.   break;
  119. case DAC960_PG_Controller:
  120.   DAC960_PG_DisableInterrupts(Controller->BaseAddress);
  121.   DAC960_PG_AcknowledgeHardwareMailboxStatus(BaseAddress);
  122.   udelay(1000);
  123.   while (DAC960_PG_InitializationInProgressP(BaseAddress))
  124.     {
  125.       if (DAC960_PG_ReadErrorStatus(BaseAddress, &ErrorStatus,
  126.     &Parameter0, &Parameter1) &&
  127.   DAC960_ReportErrorStatus(Controller, ErrorStatus,
  128.    Parameter0, Parameter1))
  129. goto Failure;
  130.       udelay(10);
  131.     }
  132.   if (!DAC960_V1_EnableMemoryMailboxInterface(Controller))
  133.     {
  134.       DAC960_Error("Unable to Enable Memory Mailbox Interface "
  135.    "for Controller atn", Controller);
  136.       goto Failure;
  137.     }
  138.   DAC960_PG_EnableInterrupts(Controller->BaseAddress);
  139.   if (Controller->V1.DualModeMemoryMailboxInterface)
  140.     Controller->QueueCommand = DAC960_PG_QueueCommandDualMode;
  141.   else Controller->QueueCommand = DAC960_PG_QueueCommandSingleMode;
  142.   Controller->ReadControllerConfiguration =
  143.     DAC960_V1_ReadControllerConfiguration;
  144.   Controller->ReadDeviceConfiguration =
  145.     DAC960_V1_ReadDeviceConfiguration;
  146.   Controller->ReportDeviceConfiguration =
  147.     DAC960_V1_ReportDeviceConfiguration;
  148.   Controller->QueueReadWriteCommand =
  149.     DAC960_V1_QueueReadWriteCommand;
  150.   break;
  151. case DAC960_PD_Controller:
  152.   request_region(Controller->IO_Address, 0x80,
  153.  Controller->FullModelName);
  154.   DAC960_PD_DisableInterrupts(BaseAddress);
  155.   DAC960_PD_AcknowledgeStatus(BaseAddress);
  156.   udelay(1000);
  157.   while (DAC960_PD_InitializationInProgressP(BaseAddress))
  158.     {
  159.       if (DAC960_PD_ReadErrorStatus(BaseAddress, &ErrorStatus,
  160.     &Parameter0, &Parameter1) &&
  161.   DAC960_ReportErrorStatus(Controller, ErrorStatus,
  162.    Parameter0, Parameter1))
  163. goto Failure;
  164.       udelay(10);
  165.     }
  166.   DAC960_PD_EnableInterrupts(Controller->BaseAddress);
  167.   Controller->QueueCommand = DAC960_PD_QueueCommand;
  168.   Controller->ReadControllerConfiguration =
  169.     DAC960_V1_ReadControllerConfiguration;
  170.   Controller->ReadDeviceConfiguration =
  171.     DAC960_V1_ReadDeviceConfiguration;
  172.   Controller->ReportDeviceConfiguration =
  173.     DAC960_V1_ReportDeviceConfiguration;
  174.   Controller->QueueReadWriteCommand =
  175.     DAC960_V1_QueueReadWriteCommand;
  176.   break;
  177. case DAC960_P_Controller:
  178.   request_region(Controller->IO_Address, 0x80,
  179.  Controller->FullModelName);
  180.   DAC960_PD_DisableInterrupts(BaseAddress);
  181.   DAC960_PD_AcknowledgeStatus(BaseAddress);
  182.   udelay(1000);
  183.   while (DAC960_PD_InitializationInProgressP(BaseAddress))
  184.     {
  185.       if (DAC960_PD_ReadErrorStatus(BaseAddress, &ErrorStatus,
  186.     &Parameter0, &Parameter1) &&
  187.   DAC960_ReportErrorStatus(Controller, ErrorStatus,
  188.    Parameter0, Parameter1))
  189. goto Failure;
  190.       udelay(10);
  191.     }
  192.   DAC960_PD_EnableInterrupts(Controller->BaseAddress);
  193.   Controller->QueueCommand = DAC960_P_QueueCommand;
  194.   Controller->ReadControllerConfiguration =
  195.     DAC960_V1_ReadControllerConfiguration;
  196.   Controller->ReadDeviceConfiguration =
  197.     DAC960_V1_ReadDeviceConfiguration;
  198.   Controller->ReportDeviceConfiguration =
  199.     DAC960_V1_ReportDeviceConfiguration;
  200.   Controller->QueueReadWriteCommand =
  201.     DAC960_V1_QueueReadWriteCommand;
  202.   break;
  203. }
  204.       /*
  205. Acquire shared access to the IRQ Channel.
  206.       */
  207.       if (IRQ_Channel == 0)
  208. {
  209.   DAC960_Error("IRQ Channel %d illegal for Controller atn",
  210.        Controller, IRQ_Channel);
  211.   goto Failure;
  212. }
  213.       strcpy(Controller->FullModelName, "DAC960");
  214.       if (request_irq(IRQ_Channel, InterruptHandler, SA_SHIRQ,
  215.       Controller->FullModelName, Controller) < 0)
  216. {
  217.   DAC960_Error("Unable to acquire IRQ Channel %d for Controller atn",
  218.        Controller, IRQ_Channel);
  219.   goto Failure;
  220. }
  221.       Controller->IRQ_Channel = IRQ_Channel;
  222.       DAC960_ActiveControllerCount++;
  223.       Controller->InitialCommand.CommandIdentifier = 1;
  224.       Controller->InitialCommand.Controller = Controller;
  225.       Controller->Commands[0] = &Controller->InitialCommand;
  226.       Controller->FreeCommands = &Controller->InitialCommand;
  227.       Controller->ControllerDetectionSuccessful = true;
  228.       continue;
  229.     Failure:
  230.       if (IO_Address == 0)
  231. DAC960_Error("PCI Bus %d Device %d Function %d I/O Address N/A "
  232.      "PCI Address 0x%Xn", Controller,
  233.      Bus, Device, Function, PCI_Address);
  234.       else DAC960_Error("PCI Bus %d Device %d Function %d I/O Address "
  235. "0x%X PCI Address 0x%Xn", Controller,
  236. Bus, Device, Function, IO_Address, PCI_Address);
  237.       if (Controller == NULL) break;
  238.       if (Controller->MemoryMappedAddress != NULL)
  239. iounmap(Controller->MemoryMappedAddress);
  240.       if (Controller->IRQ_Channel > 0)
  241. free_irq(IRQ_Channel, Controller);
  242.     }
  243. }
  246. /*
  247.   DAC960_SortControllers sorts the Controllers by PCI Bus and Device Number.
  248. */
  250. static void DAC960_SortControllers(void)
  251. {
  252.   int ControllerNumber, LastInterchange, Bound, j;
  253.   LastInterchange = DAC960_ControllerCount-1;
  254.   while (LastInterchange > 0)
  255.     {
  256.       Bound = LastInterchange;
  257.       LastInterchange = 0;
  258.       for (j = 0; j < Bound; j++)
  259. {
  260.   DAC960_Controller_T *Controller1 = DAC960_Controllers[j];
  261.   DAC960_Controller_T *Controller2 = DAC960_Controllers[j+1];
  262.   if (Controller1->Bus > Controller2->Bus ||
  263.       (Controller1->Bus == Controller2->Bus &&
  264.        (Controller1->Device > Controller2->Device)))
  265.     {
  266.       Controller2->ControllerNumber = j;
  267.       DAC960_Controllers[j] = Controller2;
  268.       Controller1->ControllerNumber = j+1;
  269.       DAC960_Controllers[j+1] = Controller1;
  270.       LastInterchange = j;
  271.     }
  272. }
  273.     }
  274.   for (ControllerNumber = 0;
  275.        ControllerNumber < DAC960_ControllerCount;
  276.        ControllerNumber++)
  277.     {
  278.       DAC960_Controller_T *Controller = DAC960_Controllers[ControllerNumber];
  279.       if (!Controller->ControllerDetectionSuccessful)
  280. {
  281.   DAC960_Controllers[ControllerNumber] = NULL;
  282.   kfree(Controller);
  283. }
  284.     }
  285. }
  288. /*
  289.   DAC960_InitializeController initializes Controller.
  290. */
  292. static void DAC960_InitializeController(DAC960_Controller_T *Controller)
  293. {
  294.   if (DAC960_ReadControllerConfiguration(Controller) &&
  295.       DAC960_ReportControllerConfiguration(Controller) &&
  296.       DAC960_CreateAuxiliaryStructures(Controller) &&
  297.       DAC960_ReadDeviceConfiguration(Controller) &&
  298.       DAC960_ReportDeviceConfiguration(Controller) &&
  299.       DAC960_RegisterBlockDevice(Controller))
  300.     {
  301.       /*
  302. Initialize the Monitoring Timer.
  303.       */
  304.       init_timer(&Controller->MonitoringTimer);
  305.       Controller->MonitoringTimer.expires =
  306. jiffies + DAC960_MonitoringTimerInterval;
  307.       Controller->MonitoringTimer.data = (unsigned long) Controller;
  308.       Controller->MonitoringTimer.function = DAC960_MonitoringTimerFunction;
  309.       add_timer(&Controller->MonitoringTimer);
  310.       Controller->ControllerInitialized = true;
  311.     }
  312.   else DAC960_FinalizeController(Controller);
  313. }
  316. /*
  317.   DAC960_FinalizeController finalizes Controller.
  318. */
  320. static void DAC960_FinalizeController(DAC960_Controller_T *Controller)
  321. {
  322.   if (Controller->ControllerInitialized)
  323.     {
  324.       del_timer(&Controller->MonitoringTimer);
  325.       if (Controller->FirmwareType == DAC960_V1_Controller)
  326. {
  327.   DAC960_Notice("Flushing Cache...", Controller);
  328.   DAC960_V1_ExecuteType3(Controller, DAC960_V1_Flush, NULL);
  329.   DAC960_Notice("donen", Controller);
  330.   switch (Controller->HardwareType)
  331.     {
  332.     case DAC960_LA_Controller:
  333.       if (Controller->V1.DualModeMemoryMailboxInterface)
  334. free_pages(Controller->MemoryMailboxPagesAddress,
  335.    Controller->MemoryMailboxPagesOrder);
  336.       else DAC960_LA_SaveMemoryMailboxInfo(Controller);
  337.       break;
  338.     case DAC960_PG_Controller:
  339.       if (Controller->V1.DualModeMemoryMailboxInterface)
  340. free_pages(Controller->MemoryMailboxPagesAddress,
  341.    Controller->MemoryMailboxPagesOrder);
  342.       else DAC960_PG_SaveMemoryMailboxInfo(Controller);
  343.       break;
  344.     case DAC960_PD_Controller:
  345.       release_region(Controller->IO_Address, 0x80);
  346.       break;
  347.     default:
  348.       break;
  349.     }
  350. }
  351.       else
  352. {
  353.   DAC960_Notice("Flushing Cache...", Controller);
  354.   DAC960_V2_DeviceOperation(Controller, DAC960_V2_PauseDevice,
  355.     DAC960_V2_RAID_Controller);
  356.   DAC960_Notice("donen", Controller);
  357.   free_pages(Controller->MemoryMailboxPagesAddress,
  358.      Controller->MemoryMailboxPagesOrder);
  359. }
  360.     }
  361.   free_irq(Controller->IRQ_Channel, Controller);
  362.   iounmap(Controller->MemoryMappedAddress);
  363.   DAC960_UnregisterBlockDevice(Controller);
  364.   DAC960_DestroyAuxiliaryStructures(Controller);
  365.   DAC960_Controllers[Controller->ControllerNumber] = NULL;
  366.   kfree(Controller);
  367. }
  370. /*
  371.   DAC960_Initialize initializes the DAC960 Driver.
  372. */
  374. static int DAC960_Initialize(void)
  375. {
  376.   int ControllerNumber;
  377.   DAC960_DetectControllers(DAC960_BA_Controller);
  378.   DAC960_DetectControllers(DAC960_LP_Controller);
  379.   DAC960_DetectControllers(DAC960_LA_Controller);
  380.   DAC960_DetectControllers(DAC960_PG_Controller);
  381.   DAC960_DetectControllers(DAC960_PD_Controller);
  382.   DAC960_DetectControllers(DAC960_P_Controller);
  383.   DAC960_SortControllers();
  384.   if (DAC960_ActiveControllerCount == 0) return -ENODEV;
  385.   for (ControllerNumber = 0;
  386.        ControllerNumber < DAC960_ControllerCount;
  387.        ControllerNumber++)
  388.     {
  389.       DAC960_Controller_T *Controller = DAC960_Controllers[ControllerNumber];
  390.       int LogicalDriveNumber;
  391.       if (Controller == NULL) continue;
  392.       DAC960_InitializeController(Controller);
  393.       DAC960_ComputeGenericDiskInfo(&Controller->GenericDiskInfo);
  394.       for (LogicalDriveNumber = 0;
  395.    LogicalDriveNumber < DAC960_MaxLogicalDrives;
  396.    LogicalDriveNumber++)
  397. DAC960_RegisterDisk(Controller, LogicalDriveNumber);
  398.     }
  399.   DAC960_CreateProcEntries();
  400.   register_reboot_notifier(&DAC960_NotifierBlock);
  401.   return 0;
  402. }
  405. /*
  406.   DAC960_Finalize finalizes the DAC960 Driver.
  407. */
  409. static void DAC960_Finalize(void)
  410. {
  411.   int ControllerNumber;
  412.   if (DAC960_ActiveControllerCount == 0) return;
  413.   for (ControllerNumber = 0;
  414.        ControllerNumber < DAC960_ControllerCount;
  415.        ControllerNumber++)
  416.     if (DAC960_Controllers[ControllerNumber] != NULL)
  417.       DAC960_FinalizeController(DAC960_Controllers[ControllerNumber]);
  418.   DAC960_DestroyProcEntries();
  419.   unregister_reboot_notifier(&DAC960_NotifierBlock);
  420. }
  423. /*
  424.   DAC960_Notifier is the notifier for the DAC960 Driver.
  425. */
  427. static int DAC960_Notifier(NotifierBlock_T *NotifierBlock,
  428.    unsigned long Event,
  429.    void *Buffer)
  430. {
  431.   if (!(Event == SYS_RESTART || Event == SYS_HALT || Event == SYS_POWER_OFF))
  432.     return NOTIFY_DONE;
  433.   DAC960_Finalize();
  434.   return NOTIFY_OK;
  435. }
  438. /*
  439.   DAC960_V1_QueueReadWriteCommand prepares and queues a Read/Write Command for
  440.   DAC960 V1 Firmware Controllers.
  441. */
  443. static void DAC960_V1_QueueReadWriteCommand(DAC960_Command_T *Command)
  444. {
  445.   DAC960_Controller_T *Controller = Command->Controller;
  446.   DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
  447.   DAC960_V1_ClearCommand(Command);
  448.   if (Command->SegmentCount == 1)
  449.     {
  450.       if (Command->CommandType == DAC960_ReadCommand)
  451. CommandMailbox->Type5.CommandOpcode = DAC960_V1_Read;
  452.       else CommandMailbox->Type5.CommandOpcode = DAC960_V1_Write;
  453.       CommandMailbox->Type5.LD.TransferLength = Command->BlockCount;
  454.       CommandMailbox->Type5.LD.LogicalDriveNumber = Command->LogicalDriveNumber;
  455.       CommandMailbox->Type5.LogicalBlockAddress = Command->BlockNumber;
  456.       CommandMailbox->Type5.BusAddress =
  457. Virtual_to_Bus32(Command->RequestBuffer);
  458.     }
  459.   else
  460.     {
  461.       DAC960_V1_ScatterGatherSegment_T
  462. *ScatterGatherList = Command->V1.ScatterGatherList;
  463.       BufferHeader_T *BufferHeader = Command->BufferHeader;
  464.       char *LastDataEndPointer = NULL;
  465.       int SegmentNumber = 0;
  466.       if (Command->CommandType == DAC960_ReadCommand)
  467. CommandMailbox->Type5.CommandOpcode = DAC960_V1_ReadWithScatterGather;
  468.       else
  469. CommandMailbox->Type5.CommandOpcode = DAC960_V1_WriteWithScatterGather;
  470.       CommandMailbox->Type5.LD.TransferLength = Command->BlockCount;
  471.       CommandMailbox->Type5.LD.LogicalDriveNumber = Command->LogicalDriveNumber;
  472.       CommandMailbox->Type5.LogicalBlockAddress = Command->BlockNumber;
  473.       CommandMailbox->Type5.BusAddress = Virtual_to_Bus32(ScatterGatherList);
  474.       CommandMailbox->Type5.ScatterGatherCount = Command->SegmentCount;
  475.       while (BufferHeader != NULL)
  476. {
  477.   if (BufferHeader->b_data == LastDataEndPointer)
  478.     {
  479.       ScatterGatherList[SegmentNumber-1].SegmentByteCount +=
  480. BufferHeader->b_size;
  481.       LastDataEndPointer += BufferHeader->b_size;
  482.     }
  483.   else
  484.     {
  485.       ScatterGatherList[SegmentNumber].SegmentDataPointer =
  486. Virtual_to_Bus32(BufferHeader->b_data);
  487.       ScatterGatherList[SegmentNumber].SegmentByteCount =
  488. BufferHeader->b_size;
  489.       LastDataEndPointer = BufferHeader->b_data + BufferHeader->b_size;
  490.       if (SegmentNumber++ > Controller->DriverScatterGatherLimit)
  491. panic("DAC960: Scatter/Gather Segment Overflown");
  492.     }
  493.   BufferHeader = BufferHeader->b_reqnext;
  494. }
  495.       if (SegmentNumber != Command->SegmentCount)
  496. panic("DAC960: SegmentNumber != SegmentCountn");
  497.     }
  498.   DAC960_QueueCommand(Command);
  499. }
  502. /*
  503.   DAC960_V2_QueueReadWriteCommand prepares and queues a Read/Write Command for
  504.   DAC960 V2 Firmware Controllers.
  505. */
  507. static void DAC960_V2_QueueReadWriteCommand(DAC960_Command_T *Command)
  508. {
  509.   DAC960_Controller_T *Controller = Command->Controller;
  510.   DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
  511.   DAC960_V2_ClearCommand(Command);
  512.   CommandMailbox->SCSI_10.CommandOpcode = DAC960_V2_SCSI_10;
  513.   CommandMailbox->SCSI_10.CommandControlBits.DataTransferControllerToHost =
  514.     (Command->CommandType == DAC960_ReadCommand);
  515.   CommandMailbox->SCSI_10.DataTransferSize =
  516.     Command->BlockCount << DAC960_BlockSizeBits;
  517.   CommandMailbox->SCSI_10.RequestSenseBusAddress =
  518.     Virtual_to_Bus64(&Command->V2.RequestSense);
  519.   CommandMailbox->SCSI_10.PhysicalDevice =
  520.     Controller->V2.LogicalDriveToVirtualDevice[Command->LogicalDriveNumber];
  521.   CommandMailbox->SCSI_10.RequestSenseSize =
  522.     sizeof(DAC960_SCSI_RequestSense_T);
  523.   CommandMailbox->SCSI_10.CDBLength = 10;
  524.   CommandMailbox->SCSI_10.SCSI_CDB[0] =
  525.     (Command->CommandType == DAC960_ReadCommand ? 0x28 : 0x2A);
  526.   CommandMailbox->SCSI_10.SCSI_CDB[2] = Command->BlockNumber >> 24;
  527.   CommandMailbox->SCSI_10.SCSI_CDB[3] = Command->BlockNumber >> 16;
  528.   CommandMailbox->SCSI_10.SCSI_CDB[4] = Command->BlockNumber >> 8;
  529.   CommandMailbox->SCSI_10.SCSI_CDB[5] = Command->BlockNumber;
  530.   CommandMailbox->SCSI_10.SCSI_CDB[7] = Command->BlockCount >> 8;
  531.   CommandMailbox->SCSI_10.SCSI_CDB[8] = Command->BlockCount;
  532.   if (Command->SegmentCount == 1)
  533.     {
  534.       CommandMailbox->SCSI_10.DataTransferMemoryAddress
  535.      .ScatterGatherSegments[0]
  536.      .SegmentDataPointer =
  537. Virtual_to_Bus64(Command->RequestBuffer);
  538.       CommandMailbox->SCSI_10.DataTransferMemoryAddress
  539.      .ScatterGatherSegments[0]
  540.      .SegmentByteCount =
  541. CommandMailbox->SCSI_10.DataTransferSize;
  542.     }
  543.   else
  544.     {
  545.       DAC960_V2_ScatterGatherSegment_T
  546. *ScatterGatherList = Command->V2.ScatterGatherList;
  547.       BufferHeader_T *BufferHeader = Command->BufferHeader;
  548.       char *LastDataEndPointer = NULL;
  549.       int SegmentNumber = 0;
  550.       if (Command->SegmentCount > 2)
  551. {
  552.   CommandMailbox->SCSI_10.CommandControlBits
  553.  .AdditionalScatterGatherListMemory = true;
  554.   CommandMailbox->SCSI_10.DataTransferMemoryAddress
  555.  .ExtendedScatterGather.ScatterGatherList0Length =
  556.     Command->SegmentCount;
  557.   CommandMailbox->SCSI_10.DataTransferMemoryAddress
  558.  .ExtendedScatterGather.ScatterGatherList0Address =
  559.     Virtual_to_Bus64(ScatterGatherList);
  560. }
  561.       else
  562. ScatterGatherList =
  563.   CommandMailbox->SCSI_10.DataTransferMemoryAddress
  564.  .ScatterGatherSegments;
  565.       while (BufferHeader != NULL)
  566. {
  567.   if (BufferHeader->b_data == LastDataEndPointer)
  568.     {
  569.       ScatterGatherList[SegmentNumber-1].SegmentByteCount +=
  570. BufferHeader->b_size;
  571.       LastDataEndPointer += BufferHeader->b_size;
  572.     }
  573.   else
  574.     {
  575.       ScatterGatherList[SegmentNumber].SegmentDataPointer =
  576. Virtual_to_Bus64(BufferHeader->b_data);
  577.       ScatterGatherList[SegmentNumber].SegmentByteCount =
  578. BufferHeader->b_size;
  579.       LastDataEndPointer = BufferHeader->b_data + BufferHeader->b_size;
  580.       if (SegmentNumber++ > Controller->DriverScatterGatherLimit)
  581. panic("DAC960: Scatter/Gather Segment Overflown");
  582.     }
  583.   BufferHeader = BufferHeader->b_reqnext;
  584. }
  585.       if (SegmentNumber != Command->SegmentCount)
  586. panic("DAC960: SegmentNumber != SegmentCountn");
  587.     }
  588.   DAC960_QueueCommand(Command);
  589. }
  592. /*
  593.   DAC960_ProcessRequest attempts to remove one I/O Request from Controller's
  594.   I/O Request Queue and queues it to the Controller.  WaitForCommand is true if
  595.   this function should wait for a Command to become available if necessary.
  596.   This function returns true if an I/O Request was queued and false otherwise.
  597. */
  599. static boolean DAC960_ProcessRequest(DAC960_Controller_T *Controller,
  600.      boolean WaitForCommand)
  601. {
  602.   RequestQueue_T *RequestQueue = Controller->RequestQueue;
  603.   ListHead_T *RequestQueueHead;
  604.   IO_Request_T *Request;
  605.   DAC960_Command_T *Command;
  606.   if (RequestQueue == NULL) return false;
  607.   RequestQueueHead = &RequestQueue->queue_head;
  608.   while (true)
  609.     {
  610.       if (list_empty(RequestQueueHead)) return false;
  611.       Request = blkdev_entry_next_request(RequestQueueHead);
  612.       Command = DAC960_AllocateCommand(Controller);
  613.       if (Command != NULL) break;
  614.       if (!WaitForCommand) return false;
  615.       DAC960_WaitForCommand(Controller);
  616.     }
  617.   if (Request->cmd == READ)
  618.     Command->CommandType = DAC960_ReadCommand;
  619.   else Command->CommandType = DAC960_WriteCommand;
  620.   Command->Completion = Request->waiting;
  621.   Command->LogicalDriveNumber = DAC960_LogicalDriveNumber(Request->rq_dev);
  622.   Command->BlockNumber =
  623.     Request->sector
  624.     + Controller->GenericDiskInfo.part[MINOR(Request->rq_dev)].start_sect;
  625.   Command->BlockCount = Request->nr_sectors;
  626.   Command->SegmentCount = Request->nr_segments;
  627.   Command->BufferHeader = Request->bh;
  628.   Command->RequestBuffer = Request->buffer;
  629.   blkdev_dequeue_request(Request);
  630.   blkdev_release_request(Request);
  631.   DAC960_QueueReadWriteCommand(Command);
  632.   return true;
  633. }
  636. /*
  637.   DAC960_ProcessRequests attempts to remove as many I/O Requests as possible
  638.   from Controller's I/O Request Queue and queue them to the Controller.
  639. */
  641. static inline void DAC960_ProcessRequests(DAC960_Controller_T *Controller)
  642. {
  643.   int Counter = 0;
  644.   while (DAC960_ProcessRequest(Controller, Counter++ == 0)) ;
  645. }
  648. /*
  649.   DAC960_RequestFunction is the I/O Request Function for DAC960 Controllers.
  650. */
  652. static void DAC960_RequestFunction(RequestQueue_T *RequestQueue)
  653. {
  654.   DAC960_Controller_T *Controller =
  655.     (DAC960_Controller_T *) RequestQueue->queuedata;
  656.   ProcessorFlags_T ProcessorFlags;
  657.   /*
  658.     Acquire exclusive access to Controller.
  659.   */
  660.   DAC960_AcquireControllerLockRF(Controller, &ProcessorFlags);
  661.   /*
  662.     Process I/O Requests for Controller.
  663.   */
  664.   DAC960_ProcessRequests(Controller);
  665.   /*
  666.     Release exclusive access to Controller.
  667.   */
  668.   DAC960_ReleaseControllerLockRF(Controller, &ProcessorFlags);
  669. }
  672. /*
  673.   DAC960_ProcessCompletedBuffer performs completion processing for an
  674.   individual Buffer.
  675. */
  677. static inline void DAC960_ProcessCompletedBuffer(BufferHeader_T *BufferHeader,
  678.  boolean SuccessfulIO)
  679. {
  680.   blk_finished_io(BufferHeader->b_size >> 9);
  681.   BufferHeader->b_end_io(BufferHeader, SuccessfulIO);
  682. }
  685. /*
  686.   DAC960_V1_ReadWriteError prints an appropriate error message for Command
  687.   when an error occurs on a Read or Write operation.
  688. */
  690. static void DAC960_V1_ReadWriteError(DAC960_Command_T *Command)
  691. {
  692.   DAC960_Controller_T *Controller = Command->Controller;
  693.   unsigned char *CommandName = "UNKNOWN";
  694.   switch (Command->CommandType)
  695.     {
  696.     case DAC960_ReadCommand:
  697.     case DAC960_ReadRetryCommand:
  698.       CommandName = "READ";
  699.       break;
  700.     case DAC960_WriteCommand:
  701.     case DAC960_WriteRetryCommand:
  702.       CommandName = "WRITE";
  703.       break;
  704.     case DAC960_MonitoringCommand:
  705.     case DAC960_ImmediateCommand:
  706.     case DAC960_QueuedCommand:
  707.       break;
  708.     }
  709.   switch (Command->V1.CommandStatus)
  710.     {
  711.     case DAC960_V1_IrrecoverableDataError:
  712.       DAC960_Error("Irrecoverable Data Error on %s:n",
  713.    Controller, CommandName);
  714.       break;
  715.     case DAC960_V1_LogicalDriveNonexistentOrOffline:
  716.       DAC960_Error("Logical Drive Nonexistent or Offline on %s:n",
  717.    Controller, CommandName);
  718.       break;
  719.     case DAC960_V1_AccessBeyondEndOfLogicalDrive:
  720.       DAC960_Error("Attempt to Access Beyond End of Logical Drive "
  721.    "on %s:n", Controller, CommandName);
  722.       break;
  723.     case DAC960_V1_BadDataEncountered:
  724.       DAC960_Error("Bad Data Encountered on %s:n", Controller, CommandName);
  725.       break;
  726.     default:
  727.       DAC960_Error("Unexpected Error Status %04X on %s:n",
  728.    Controller, Command->V1.CommandStatus, CommandName);
  729.       break;
  730.     }
  731.   DAC960_Error("  /dev/rd/c%dd%d:   absolute blocks %u..%un",
  732.        Controller, Controller->ControllerNumber,
  733.        Command->LogicalDriveNumber, Command->BlockNumber,
  734.        Command->BlockNumber + Command->BlockCount - 1);
  735.   if (DAC960_PartitionNumber(Command->BufferHeader->b_rdev) > 0)
  736.     DAC960_Error("  /dev/rd/c%dd%dp%d: relative blocks %u..%un",
  737.  Controller, Controller->ControllerNumber,
  738.  Command->LogicalDriveNumber,
  739.  DAC960_PartitionNumber(Command->BufferHeader->b_rdev),
  740.  Command->BufferHeader->b_rsector,
  741.  Command->BufferHeader->b_rsector + Command->BlockCount - 1);
  742. }
  745. /*
  746.   DAC960_V1_ProcessCompletedCommand performs completion processing for Command
  747.   for DAC960 V1 Firmware Controllers.
  748. */
  750. static void DAC960_V1_ProcessCompletedCommand(DAC960_Command_T *Command)
  751. {
  752.   DAC960_Controller_T *Controller = Command->Controller;
  753.   DAC960_CommandType_T CommandType = Command->CommandType;
  754.   DAC960_V1_CommandOpcode_T CommandOpcode =
  755.     Command->V1.CommandMailbox.Common.CommandOpcode;
  756.   DAC960_V1_CommandStatus_T CommandStatus = Command->V1.CommandStatus;
  757.   BufferHeader_T *BufferHeader = Command->BufferHeader;
  758.   if (CommandType == DAC960_ReadCommand ||
  759.       CommandType == DAC960_WriteCommand)
  760.     {
  761.       if (CommandStatus == DAC960_V1_NormalCompletion)
  762. {
  763.   /*
  764.     Perform completion processing for all buffers in this I/O Request.
  765.   */
  766.   while (BufferHeader != NULL)
  767.     {
  768.       BufferHeader_T *NextBufferHeader = BufferHeader->b_reqnext;
  769.       BufferHeader->b_reqnext = NULL;
  770.       DAC960_ProcessCompletedBuffer(BufferHeader, true);
  771.       BufferHeader = NextBufferHeader;
  772.     }
  773.   if (Command->Completion != NULL)
  774.     {
  775.       complete(Command->Completion);
  776.       Command->Completion = NULL;
  777.     }
  778.   add_blkdev_randomness(DAC960_MAJOR + Controller->ControllerNumber);
  779. }
  780.       else if ((CommandStatus == DAC960_V1_IrrecoverableDataError ||
  781. CommandStatus == DAC960_V1_BadDataEncountered) &&
  782.        BufferHeader != NULL &&
  783.        BufferHeader->b_reqnext != NULL)
  784. {
  785.   DAC960_V1_CommandMailbox_T *CommandMailbox =
  786.     &Command->V1.CommandMailbox;
  787.   if (CommandType == DAC960_ReadCommand)
  788.     {
  789.       Command->CommandType = DAC960_ReadRetryCommand;
  790.       CommandMailbox->Type5.CommandOpcode = DAC960_V1_Read;
  791.     }
  792.   else
  793.     {
  794.       Command->CommandType = DAC960_WriteRetryCommand;
  795.       CommandMailbox->Type5.CommandOpcode = DAC960_V1_Write;
  796.     }
  797.   Command->BlockCount = BufferHeader->b_size >> DAC960_BlockSizeBits;
  798.   CommandMailbox->Type5.LD.TransferLength = Command->BlockCount;
  799.   CommandMailbox->Type5.BusAddress =
  800.     Virtual_to_Bus32(BufferHeader->b_data);
  801.   DAC960_QueueCommand(Command);
  802.   return;
  803. }
  804.       else
  805. {
  806.   if (CommandStatus != DAC960_V1_LogicalDriveNonexistentOrOffline)
  807.     DAC960_V1_ReadWriteError(Command);
  808.   /*
  809.     Perform completion processing for all buffers in this I/O Request.
  810.   */
  811.   while (BufferHeader != NULL)
  812.     {
  813.       BufferHeader_T *NextBufferHeader = BufferHeader->b_reqnext;
  814.       BufferHeader->b_reqnext = NULL;
  815.       DAC960_ProcessCompletedBuffer(BufferHeader, false);
  816.       BufferHeader = NextBufferHeader;
  817.     }
  818.   if (Command->Completion != NULL)
  819.     {
  820.       complete(Command->Completion);
  821.       Command->Completion = NULL;
  822.     }
  823. }
  824.     }
  825.   else if (CommandType == DAC960_ReadRetryCommand ||
  826.    CommandType == DAC960_WriteRetryCommand)
  827.     {
  828.       BufferHeader_T *NextBufferHeader = BufferHeader->b_reqnext;
  829.       BufferHeader->b_reqnext = NULL;
  830.       /*
  831. Perform completion processing for this single buffer.
  832.       */
  833.       if (CommandStatus == DAC960_V1_NormalCompletion)
  834. DAC960_ProcessCompletedBuffer(BufferHeader, true);
  835.       else
  836. {
  837.   if (CommandStatus != DAC960_V1_LogicalDriveNonexistentOrOffline)
  838.     DAC960_V1_ReadWriteError(Command);
  839.   DAC960_ProcessCompletedBuffer(BufferHeader, false);
  840. }
  841.       if (NextBufferHeader != NULL)
  842. {
  843.   DAC960_V1_CommandMailbox_T *CommandMailbox =
  844.     &Command->V1.CommandMailbox;
  845.   Command->BlockNumber +=
  846.     BufferHeader->b_size >> DAC960_BlockSizeBits;
  847.   Command->BlockCount =
  848.     NextBufferHeader->b_size >> DAC960_BlockSizeBits;
  849.   Command->BufferHeader = NextBufferHeader;
  850.   CommandMailbox->Type5.LD.TransferLength = Command->BlockCount;
  851.   CommandMailbox->Type5.LogicalBlockAddress = Command->BlockNumber;
  852.   CommandMailbox->Type5.BusAddress =
  853.     Virtual_to_Bus32(NextBufferHeader->b_data);
  854.   DAC960_QueueCommand(Command);
  855.   return;
  856. }
  857.     }
  858.   else if (CommandType == DAC960_MonitoringCommand ||
  859.    CommandOpcode == DAC960_V1_Enquiry ||
  860.    CommandOpcode == DAC960_V1_GetRebuildProgress)
  861.     {
  862.       if (CommandType != DAC960_MonitoringCommand)
  863. {
  864.   if (CommandOpcode == DAC960_V1_Enquiry)
  865.     memcpy(&Controller->V1.NewEnquiry,
  866.    Bus32_to_Virtual(Command->V1.CommandMailbox
  867.        .Type3.BusAddress),
  868.    sizeof(DAC960_V1_Enquiry_T));
  869.   else if (CommandOpcode == DAC960_V1_GetRebuildProgress)
  870.     memcpy(&Controller->V1.RebuildProgress,
  871.    Bus32_to_Virtual(Command->V1.CommandMailbox
  872.        .Type3.BusAddress),
  873.    sizeof(DAC960_V1_RebuildProgress_T));
  874. }
  875.       if (CommandOpcode == DAC960_V1_Enquiry &&
  876.   Controller->ControllerInitialized)
  877. {
  878.   DAC960_V1_Enquiry_T *OldEnquiry = &Controller->V1.Enquiry;
  879.   DAC960_V1_Enquiry_T *NewEnquiry = &Controller->V1.NewEnquiry;
  880.   unsigned int OldCriticalLogicalDriveCount =
  881.     OldEnquiry->CriticalLogicalDriveCount;
  882.   unsigned int NewCriticalLogicalDriveCount =
  883.     NewEnquiry->CriticalLogicalDriveCount;
  884.   if (NewEnquiry->NumberOfLogicalDrives > Controller->LogicalDriveCount)
  885.     {
  886.       int LogicalDriveNumber = Controller->LogicalDriveCount - 1;
  887.       while (++LogicalDriveNumber < NewEnquiry->NumberOfLogicalDrives)
  888. DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
  889. "Now Existsn", Controller,
  890. LogicalDriveNumber,
  891. Controller->ControllerNumber,
  892. LogicalDriveNumber);
  893.       Controller->LogicalDriveCount = NewEnquiry->NumberOfLogicalDrives;
  894.       DAC960_ComputeGenericDiskInfo(&Controller->GenericDiskInfo);
  895.     }
  896.   if (NewEnquiry->NumberOfLogicalDrives < Controller->LogicalDriveCount)
  897.     {
  898.       int LogicalDriveNumber = NewEnquiry->NumberOfLogicalDrives - 1;
  899.       while (++LogicalDriveNumber < Controller->LogicalDriveCount)
  900. DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
  901. "No Longer Existsn", Controller,
  902. LogicalDriveNumber,
  903. Controller->ControllerNumber,
  904. LogicalDriveNumber);
  905.       Controller->LogicalDriveCount = NewEnquiry->NumberOfLogicalDrives;
  906.       DAC960_ComputeGenericDiskInfo(&Controller->GenericDiskInfo);
  907.     }
  908.   if (NewEnquiry->StatusFlags.DeferredWriteError !=
  909.       OldEnquiry->StatusFlags.DeferredWriteError)
  910.     DAC960_Critical("Deferred Write Error Flag is now %sn", Controller,
  911.     (NewEnquiry->StatusFlags.DeferredWriteError
  912.      ? "TRUE" : "FALSE"));
  913.   if ((NewCriticalLogicalDriveCount > 0 ||
  914.        NewCriticalLogicalDriveCount != OldCriticalLogicalDriveCount) ||
  915.       (NewEnquiry->OfflineLogicalDriveCount > 0 ||
  916.        NewEnquiry->OfflineLogicalDriveCount !=
  917.        OldEnquiry->OfflineLogicalDriveCount) ||
  918.       (NewEnquiry->DeadDriveCount > 0 ||
  919.        NewEnquiry->DeadDriveCount !=
  920.        OldEnquiry->DeadDriveCount) ||
  921.       (NewEnquiry->EventLogSequenceNumber !=
  922.        OldEnquiry->EventLogSequenceNumber) ||
  923.       Controller->MonitoringTimerCount == 0 ||
  924.       (jiffies - Controller->SecondaryMonitoringTime
  925.        >= DAC960_SecondaryMonitoringInterval))
  926.     {
  927.       Controller->V1.NeedLogicalDriveInformation = true;
  928.       Controller->V1.NewEventLogSequenceNumber =
  929. NewEnquiry->EventLogSequenceNumber;
  930.       Controller->V1.NeedErrorTableInformation = true;
  931.       Controller->V1.NeedDeviceStateInformation = true;
  932.       Controller->V1.StartDeviceStateScan = true;
  933.       Controller->V1.NeedBackgroundInitializationStatus =
  934. Controller->V1.BackgroundInitializationStatusSupported;
  935.       Controller->SecondaryMonitoringTime = jiffies;
  936.     }
  937.   if (NewEnquiry->RebuildFlag == DAC960_V1_StandbyRebuildInProgress ||
  938.       NewEnquiry->RebuildFlag
  939.       == DAC960_V1_BackgroundRebuildInProgress ||
  940.       OldEnquiry->RebuildFlag == DAC960_V1_StandbyRebuildInProgress ||
  941.       OldEnquiry->RebuildFlag == DAC960_V1_BackgroundRebuildInProgress)
  942.     {
  943.       Controller->V1.NeedRebuildProgress = true;
  944.       Controller->V1.RebuildProgressFirst =
  945. (NewEnquiry->CriticalLogicalDriveCount <
  946.  OldEnquiry->CriticalLogicalDriveCount);
  947.     }
  948.   if (OldEnquiry->RebuildFlag == DAC960_V1_BackgroundCheckInProgress)
  949.     switch (NewEnquiry->RebuildFlag)
  950.       {
  951.       case DAC960_V1_NoStandbyRebuildOrCheckInProgress:
  952. DAC960_Progress("Consistency Check Completed Successfullyn",
  953. Controller);
  954. break;
  955.       case DAC960_V1_StandbyRebuildInProgress:
  956.       case DAC960_V1_BackgroundRebuildInProgress:
  957. break;
  958.       case DAC960_V1_BackgroundCheckInProgress:
  959. Controller->V1.NeedConsistencyCheckProgress = true;
  960. break;
  961.       case DAC960_V1_StandbyRebuildCompletedWithError:
  962. DAC960_Progress("Consistency Check Completed with Errorn",
  963. Controller);
  964. break;
  965.       case DAC960_V1_BackgroundRebuildOrCheckFailed_DriveFailed:
  966. DAC960_Progress("Consistency Check Failed - "
  967. "Physical Device Failedn", Controller);
  968. break;
  969.       case DAC960_V1_BackgroundRebuildOrCheckFailed_LogicalDriveFailed:
  970. DAC960_Progress("Consistency Check Failed - "
  971. "Logical Drive Failedn", Controller);
  972. break;
  973.       case DAC960_V1_BackgroundRebuildOrCheckFailed_OtherCauses:
  974. DAC960_Progress("Consistency Check Failed - Other Causesn",
  975. Controller);
  976. break;
  977.       case DAC960_V1_BackgroundRebuildOrCheckSuccessfullyTerminated:
  978. DAC960_Progress("Consistency Check Successfully Terminatedn",
  979. Controller);
  980. break;
  981.       }
  982.   else if (NewEnquiry->RebuildFlag
  983.    == DAC960_V1_BackgroundCheckInProgress)
  984.     Controller->V1.NeedConsistencyCheckProgress = true;
  985.   Controller->MonitoringAlertMode =
  986.     (NewEnquiry->CriticalLogicalDriveCount > 0 ||
  987.      NewEnquiry->OfflineLogicalDriveCount > 0 ||
  988.      NewEnquiry->DeadDriveCount > 0);
  989.   if (CommandType != DAC960_MonitoringCommand &&
  990.       Controller->V1.RebuildFlagPending)
  991.     {
  992.       DAC960_V1_Enquiry_T *Enquiry = (DAC960_V1_Enquiry_T *)
  993. Bus32_to_Virtual(Command->V1.CommandMailbox.Type3.BusAddress);
  994.       Enquiry->RebuildFlag = Controller->V1.PendingRebuildFlag;
  995.       Controller->V1.RebuildFlagPending = false;
  996.     }
  997.   else if (CommandType == DAC960_MonitoringCommand &&
  998.    NewEnquiry->RebuildFlag >
  999.    DAC960_V1_BackgroundCheckInProgress)
  1000.     {
  1001.       Controller->V1.PendingRebuildFlag = NewEnquiry->RebuildFlag;
  1002.       Controller->V1.RebuildFlagPending = true;
  1003.     }
  1004.   memcpy(&Controller->V1.Enquiry, &Controller->V1.NewEnquiry,
  1005.  sizeof(DAC960_V1_Enquiry_T));
  1006. }
  1007.       else if (CommandOpcode == DAC960_V1_PerformEventLogOperation)
  1008. {
  1009.   static char
  1010.     *DAC960_EventMessages[] =
  1011.        { "killed because write recovery failed",
  1012.  "killed because of SCSI bus reset failure",
  1013.  "killed because of double check condition",
  1014.  "killed because it was removed",
  1015.  "killed because of gross error on SCSI chip",
  1016.  "killed because of bad tag returned from drive",
  1017.  "killed because of timeout on SCSI command",
  1018.  "killed because of reset SCSI command issued from system",
  1019.  "killed because busy or parity error count exceeded limit",
  1020.  "killed because of 'kill drive' command from system",
  1021.  "killed because of selection timeout",
  1022.  "killed due to SCSI phase sequence error",
  1023.  "killed due to unknown status" };
  1024.   DAC960_V1_EventLogEntry_T *EventLogEntry =
  1025.     &Controller->V1.EventLogEntry;
  1026.   if (EventLogEntry->SequenceNumber ==
  1027.       Controller->V1.OldEventLogSequenceNumber)
  1028.     {
  1029.       unsigned char SenseKey = EventLogEntry->SenseKey;
  1030.       unsigned char AdditionalSenseCode =
  1031. EventLogEntry->AdditionalSenseCode;
  1032.       unsigned char AdditionalSenseCodeQualifier =
  1033. EventLogEntry->AdditionalSenseCodeQualifier;
  1034.       if (SenseKey == DAC960_SenseKey_VendorSpecific &&
  1035.   AdditionalSenseCode == 0x80 &&
  1036.   AdditionalSenseCodeQualifier <
  1037.   sizeof(DAC960_EventMessages) / sizeof(char *))
  1038. DAC960_Critical("Physical Device %d:%d %sn", Controller,
  1039. EventLogEntry->Channel,
  1040. EventLogEntry->TargetID,
  1041. DAC960_EventMessages[
  1042.   AdditionalSenseCodeQualifier]);
  1043.       else if (SenseKey == DAC960_SenseKey_UnitAttention &&
  1044.        AdditionalSenseCode == 0x29)
  1045. {
  1046.   if (Controller->MonitoringTimerCount > 0)
  1047.     Controller->V1.DeviceResetCount[EventLogEntry->Channel]
  1048.    [EventLogEntry->TargetID]++;
  1049. }
  1050.       else if (!(SenseKey == DAC960_SenseKey_NoSense ||
  1051.  (SenseKey == DAC960_SenseKey_NotReady &&
  1052.   AdditionalSenseCode == 0x04 &&
  1053.   (AdditionalSenseCodeQualifier == 0x01 ||
  1054.    AdditionalSenseCodeQualifier == 0x02))))
  1055. {
  1056.   DAC960_Critical("Physical Device %d:%d Error Log: "
  1057.   "Sense Key = %X, ASC = %02X, ASCQ = %02Xn",
  1058.   Controller,
  1059.   EventLogEntry->Channel,
  1060.   EventLogEntry->TargetID,
  1061.   SenseKey,
  1062.   AdditionalSenseCode,
  1063.   AdditionalSenseCodeQualifier);
  1064.   DAC960_Critical("Physical Device %d:%d Error Log: "
  1065.   "Information = %02X%02X%02X%02X "
  1066.   "%02X%02X%02X%02Xn",
  1067.   Controller,
  1068.   EventLogEntry->Channel,
  1069.   EventLogEntry->TargetID,
  1070.   EventLogEntry->Information[0],
  1071.   EventLogEntry->Information[1],
  1072.   EventLogEntry->Information[2],
  1073.   EventLogEntry->Information[3],
  1074.   EventLogEntry->CommandSpecificInformation[0],
  1075.   EventLogEntry->CommandSpecificInformation[1],
  1076.   EventLogEntry->CommandSpecificInformation[2],
  1077.   EventLogEntry->CommandSpecificInformation[3]);
  1078. }
  1079.     }
  1080.   Controller->V1.OldEventLogSequenceNumber++;
  1081. }
  1082.       else if (CommandOpcode == DAC960_V1_GetErrorTable)
  1083. {
  1084.   DAC960_V1_ErrorTable_T *OldErrorTable = &Controller->V1.ErrorTable;
  1085.   DAC960_V1_ErrorTable_T *NewErrorTable = &Controller->V1.NewErrorTable;
  1086.   int Channel, TargetID;
  1087.   for (Channel = 0; Channel < Controller->Channels; Channel++)
  1088.     for (TargetID = 0; TargetID < Controller->Targets; TargetID++)
  1089.       {
  1090. DAC960_V1_ErrorTableEntry_T *NewErrorEntry =
  1091.   &NewErrorTable->ErrorTableEntries[Channel][TargetID];
  1092. DAC960_V1_ErrorTableEntry_T *OldErrorEntry =
  1093.   &OldErrorTable->ErrorTableEntries[Channel][TargetID];
  1094. if ((NewErrorEntry->ParityErrorCount !=
  1095.      OldErrorEntry->ParityErrorCount) ||
  1096.     (NewErrorEntry->SoftErrorCount !=
  1097.      OldErrorEntry->SoftErrorCount) ||
  1098.     (NewErrorEntry->HardErrorCount !=
  1099.      OldErrorEntry->HardErrorCount) ||
  1100.     (NewErrorEntry->MiscErrorCount !=
  1101.      OldErrorEntry->MiscErrorCount))
  1102.   DAC960_Critical("Physical Device %d:%d Errors: "
  1103.   "Parity = %d, Soft = %d, "
  1104.   "Hard = %d, Misc = %dn",
  1105.   Controller, Channel, TargetID,
  1106.   NewErrorEntry->ParityErrorCount,
  1107.   NewErrorEntry->SoftErrorCount,
  1108.   NewErrorEntry->HardErrorCount,
  1109.   NewErrorEntry->MiscErrorCount);
  1110.       }
  1111.   memcpy(&Controller->V1.ErrorTable, &Controller->V1.NewErrorTable,
  1112.  sizeof(DAC960_V1_ErrorTable_T));
  1113. }
  1114.       else if (CommandOpcode == DAC960_V1_GetDeviceState)
  1115. {
  1116.   DAC960_V1_DeviceState_T *OldDeviceState =
  1117.     &Controller->V1.DeviceState[Controller->V1.DeviceStateChannel]
  1118.        [Controller->V1.DeviceStateTargetID];
  1119.   DAC960_V1_DeviceState_T *NewDeviceState =
  1120.     &Controller->V1.NewDeviceState;
  1121.   if (NewDeviceState->DeviceState != OldDeviceState->DeviceState)
  1122.     DAC960_Critical("Physical Device %d:%d is now %sn", Controller,
  1123.     Controller->V1.DeviceStateChannel,
  1124.     Controller->V1.DeviceStateTargetID,
  1125.     (NewDeviceState->DeviceState
  1126.      == DAC960_V1_Device_Dead
  1127.      ? "DEAD"
  1128.      : NewDeviceState->DeviceState
  1129.        == DAC960_V1_Device_WriteOnly
  1130.        ? "WRITE-ONLY"
  1131.        : NewDeviceState->DeviceState
  1132.  == DAC960_V1_Device_Online
  1133.  ? "ONLINE" : "STANDBY"));
  1134.   if (OldDeviceState->DeviceState == DAC960_V1_Device_Dead &&
  1135.       NewDeviceState->DeviceState != DAC960_V1_Device_Dead)
  1136.     {
  1137.       Controller->V1.NeedDeviceInquiryInformation = true;
  1138.       Controller->V1.NeedDeviceSerialNumberInformation = true;
  1139.       Controller->V1.DeviceResetCount
  1140.      [Controller->V1.DeviceStateChannel]
  1141.      [Controller->V1.DeviceStateTargetID] = 0;
  1142.     }
  1143.   memcpy(OldDeviceState, NewDeviceState,
  1144.  sizeof(DAC960_V1_DeviceState_T));
  1145. }
  1146.       else if (CommandOpcode == DAC960_V1_GetLogicalDriveInformation)
  1147. {
  1148.   int LogicalDriveNumber;
  1149.   for (LogicalDriveNumber = 0;
  1150.        LogicalDriveNumber < Controller->LogicalDriveCount;
  1151.        LogicalDriveNumber++)
  1152.     {
  1153.       DAC960_V1_LogicalDriveInformation_T *OldLogicalDriveInformation =
  1154. &Controller->V1.LogicalDriveInformation[LogicalDriveNumber];
  1155.       DAC960_V1_LogicalDriveInformation_T *NewLogicalDriveInformation =
  1156. &Controller->V1.NewLogicalDriveInformation[LogicalDriveNumber];
  1157.       if (NewLogicalDriveInformation->LogicalDriveState !=
  1158.   OldLogicalDriveInformation->LogicalDriveState)
  1159. DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
  1160. "is now %sn", Controller,
  1161. LogicalDriveNumber,
  1162. Controller->ControllerNumber,
  1163. LogicalDriveNumber,
  1164. (NewLogicalDriveInformation->LogicalDriveState
  1165.  == DAC960_V1_LogicalDrive_Online
  1166.  ? "ONLINE"
  1167.  : NewLogicalDriveInformation->LogicalDriveState
  1168.    == DAC960_V1_LogicalDrive_Critical
  1169.    ? "CRITICAL" : "OFFLINE"));
  1170.       if (NewLogicalDriveInformation->WriteBack !=
  1171.   OldLogicalDriveInformation->WriteBack)
  1172. DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
  1173. "is now %sn", Controller,
  1174. LogicalDriveNumber,
  1175. Controller->ControllerNumber,
  1176. LogicalDriveNumber,
  1177. (NewLogicalDriveInformation->WriteBack
  1178.  ? "WRITE BACK" : "WRITE THRU"));
  1179.     }
  1180.   memcpy(&Controller->V1.LogicalDriveInformation,
  1181.  &Controller->V1.NewLogicalDriveInformation,
  1182.  sizeof(DAC960_V1_LogicalDriveInformationArray_T));
  1183. }
  1184.       else if (CommandOpcode == DAC960_V1_GetRebuildProgress)
  1185. {
  1186.   unsigned int LogicalDriveNumber =
  1187.     Controller->V1.RebuildProgress.LogicalDriveNumber;
  1188.   unsigned int LogicalDriveSize =
  1189.     Controller->V1.RebuildProgress.LogicalDriveSize;
  1190.   unsigned int BlocksCompleted =
  1191.     LogicalDriveSize - Controller->V1.RebuildProgress.RemainingBlocks;
  1192.   if (CommandStatus == DAC960_V1_NoRebuildOrCheckInProgress &&
  1193.       Controller->V1.LastRebuildStatus == DAC960_V1_NormalCompletion)
  1194.     CommandStatus = DAC960_V1_RebuildSuccessful;
  1195.   switch (CommandStatus)
  1196.     {
  1197.     case DAC960_V1_NormalCompletion:
  1198.       Controller->EphemeralProgressMessage = true;
  1199.       DAC960_Progress("Rebuild in Progress: "
  1200.       "Logical Drive %d (/dev/rd/c%dd%d) "
  1201.       "%d%% completedn",
  1202.       Controller, LogicalDriveNumber,
  1203.       Controller->ControllerNumber,
  1204.       LogicalDriveNumber,
  1205.       (100 * (BlocksCompleted >> 7))
  1206.       / (LogicalDriveSize >> 7));
  1207.       Controller->EphemeralProgressMessage = false;
  1208.       break;
  1209.     case DAC960_V1_RebuildFailed_LogicalDriveFailure:
  1210.       DAC960_Progress("Rebuild Failed due to "
  1211.       "Logical Drive Failuren", Controller);
  1212.       break;
  1213.     case DAC960_V1_RebuildFailed_BadBlocksOnOther:
  1214.       DAC960_Progress("Rebuild Failed due to "
  1215.       "Bad Blocks on Other Drivesn", Controller);
  1216.       break;
  1217.     case DAC960_V1_RebuildFailed_NewDriveFailed:
  1218.       DAC960_Progress("Rebuild Failed due to "
  1219.       "Failure of Drive Being Rebuiltn", Controller);
  1220.       break;
  1221.     case DAC960_V1_NoRebuildOrCheckInProgress:
  1222.       break;
  1223.     case DAC960_V1_RebuildSuccessful:
  1224.       DAC960_Progress("Rebuild Completed Successfullyn", Controller);
  1225.       break;
  1226.     case DAC960_V1_RebuildSuccessfullyTerminated:
  1227.       DAC960_Progress("Rebuild Successfully Terminatedn", Controller);
  1228.       break;
  1229.     }
  1230.   Controller->V1.LastRebuildStatus = CommandStatus;
  1231.   if (CommandType != DAC960_MonitoringCommand &&
  1232.       Controller->V1.RebuildStatusPending)
  1233.     {
  1234.       Command->V1.CommandStatus = Controller->V1.PendingRebuildStatus;
  1235.       Controller->V1.RebuildStatusPending = false;
  1236.     }
  1237.   else if (CommandType == DAC960_MonitoringCommand &&
  1238.    CommandStatus != DAC960_V1_NormalCompletion &&
  1239.    CommandStatus != DAC960_V1_NoRebuildOrCheckInProgress)
  1240.     {
  1241.       Controller->V1.PendingRebuildStatus = CommandStatus;
  1242.       Controller->V1.RebuildStatusPending = true;
  1243.     }
  1244. }
  1245.       else if (CommandOpcode == DAC960_V1_RebuildStat)
  1246. {
  1247.   unsigned int LogicalDriveNumber =
  1248.     Controller->V1.RebuildProgress.LogicalDriveNumber;
  1249.   unsigned int LogicalDriveSize =
  1250.     Controller->V1.RebuildProgress.LogicalDriveSize;
  1251.   unsigned int BlocksCompleted =
  1252.     LogicalDriveSize - Controller->V1.RebuildProgress.RemainingBlocks;
  1253.   if (CommandStatus == DAC960_V1_NormalCompletion)
  1254.     {
  1255.       Controller->EphemeralProgressMessage = true;
  1256.       DAC960_Progress("Consistency Check in Progress: "
  1257.       "Logical Drive %d (/dev/rd/c%dd%d) "
  1258.       "%d%% completedn",
  1259.       Controller, LogicalDriveNumber,
  1260.       Controller->ControllerNumber,
  1261.       LogicalDriveNumber,
  1262.       (100 * (BlocksCompleted >> 7))
  1263.       / (LogicalDriveSize >> 7));
  1264.       Controller->EphemeralProgressMessage = false;
  1265.     }
  1266. }
  1267.       else if (CommandOpcode == DAC960_V1_BackgroundInitializationControl)
  1268. {
  1269.   unsigned int LogicalDriveNumber =
  1270.     Controller->V1.BackgroundInitializationStatus.LogicalDriveNumber;
  1271.   unsigned int LogicalDriveSize =
  1272.     Controller->V1.BackgroundInitializationStatus.LogicalDriveSize;
  1273.   unsigned int BlocksCompleted =
  1274.     Controller->V1.BackgroundInitializationStatus.BlocksCompleted;
  1275.   switch (CommandStatus)
  1276.     {
  1277.     case DAC960_V1_NormalCompletion:
  1278.       switch (Controller->V1.BackgroundInitializationStatus.Status)
  1279. {
  1280. case DAC960_V1_BackgroundInitializationInvalid:
  1281.   break;
  1282. case DAC960_V1_BackgroundInitializationStarted:
  1283.   DAC960_Progress("Background Initialization Startedn",
  1284.   Controller);
  1285.   break;
  1286. case DAC960_V1_BackgroundInitializationInProgress:
  1287.   if (BlocksCompleted ==
  1288.       Controller->V1.LastBackgroundInitializationStatus
  1289.     .BlocksCompleted &&
  1290.       LogicalDriveNumber ==
  1291.       Controller->V1.LastBackgroundInitializationStatus
  1292.     .LogicalDriveNumber)
  1293.     break;
  1294.   Controller->EphemeralProgressMessage = true;
  1295.   DAC960_Progress("Background Initialization in Progress: "
  1296.   "Logical Drive %d (/dev/rd/c%dd%d) "
  1297.   "%d%% completedn",
  1298.   Controller, LogicalDriveNumber,
  1299.   Controller->ControllerNumber,
  1300.   LogicalDriveNumber,
  1301.   (100 * (BlocksCompleted >> 7))
  1302.   / (LogicalDriveSize >> 7));
  1303.   Controller->EphemeralProgressMessage = false;
  1304.   break;
  1305. case DAC960_V1_BackgroundInitializationSuspended:
  1306.   DAC960_Progress("Background Initialization Suspendedn",
  1307.   Controller);
  1308.   break;
  1309. case DAC960_V1_BackgroundInitializationCancelled:
  1310.   DAC960_Progress("Background Initialization Cancelledn",
  1311.   Controller);
  1312.   break;
  1313. }
  1314.       memcpy(&Controller->V1.LastBackgroundInitializationStatus,
  1315.      &Controller->V1.BackgroundInitializationStatus,
  1316.      sizeof(DAC960_V1_BackgroundInitializationStatus_T));
  1317.       break;
  1318.     case DAC960_V1_BackgroundInitSuccessful:
  1319.       if (Controller->V1.BackgroundInitializationStatus.Status ==
  1320.   DAC960_V1_BackgroundInitializationInProgress)
  1321. DAC960_Progress("Background Initialization "
  1322. "Completed Successfullyn", Controller);
  1323.       Controller->V1.BackgroundInitializationStatus.Status =
  1324. DAC960_V1_BackgroundInitializationInvalid;
  1325.       break;
  1326.     case DAC960_V1_BackgroundInitAborted:
  1327.       if (Controller->V1.BackgroundInitializationStatus.Status ==
  1328.   DAC960_V1_BackgroundInitializationInProgress)
  1329. DAC960_Progress("Background Initialization Abortedn",
  1330. Controller);
  1331.       Controller->V1.BackgroundInitializationStatus.Status =
  1332. DAC960_V1_BackgroundInitializationInvalid;
  1333.       break;
  1334.     case DAC960_V1_NoBackgroundInitInProgress:
  1335.       break;
  1336.     }
  1337. }
  1338.     }
  1339.   if (CommandType == DAC960_MonitoringCommand)
  1340.     {
  1341.       if (Controller->V1.NewEventLogSequenceNumber
  1342.   - Controller->V1.OldEventLogSequenceNumber > 0)
  1343. {
  1344.   Command->V1.CommandMailbox.Type3E.CommandOpcode =
  1345.     DAC960_V1_PerformEventLogOperation;
  1346.   Command->V1.CommandMailbox.Type3E.OperationType =
  1347.     DAC960_V1_GetEventLogEntry;
  1348.   Command->V1.CommandMailbox.Type3E.OperationQualifier = 1;
  1349.   Command->V1.CommandMailbox.Type3E.SequenceNumber =
  1350.     Controller->V1.OldEventLogSequenceNumber;
  1351.   Command->V1.CommandMailbox.Type3E.BusAddress =
  1352.     Virtual_to_Bus32(&Controller->V1.EventLogEntry);
  1353.   DAC960_QueueCommand(Command);
  1354.   return;
  1355. }
  1356.       if (Controller->V1.NeedErrorTableInformation)
  1357. {
  1358.   Controller->V1.NeedErrorTableInformation = false;
  1359.   Command->V1.CommandMailbox.Type3.CommandOpcode =
  1360.     DAC960_V1_GetErrorTable;
  1361.   Command->V1.CommandMailbox.Type3.BusAddress =
  1362.     Virtual_to_Bus32(&Controller->V1.NewErrorTable);
  1363.   DAC960_QueueCommand(Command);
  1364.   return;
  1365. }
  1366.       if (Controller->V1.NeedRebuildProgress &&
  1367.   Controller->V1.RebuildProgressFirst)
  1368. {
  1369.   Controller->V1.NeedRebuildProgress = false;
  1370.   Command->V1.CommandMailbox.Type3.CommandOpcode =
  1371.     DAC960_V1_GetRebuildProgress;
  1372.   Command->V1.CommandMailbox.Type3.BusAddress =
  1373.     Virtual_to_Bus32(&Controller->V1.RebuildProgress);
  1374.   DAC960_QueueCommand(Command);
  1375.   return;
  1376. }
  1377.       if (Controller->V1.NeedDeviceStateInformation)
  1378. {
  1379.   if (Controller->V1.NeedDeviceInquiryInformation)
  1380.     {
  1381.       DAC960_V1_DCDB_T *DCDB = &Controller->V1.MonitoringDCDB;
  1382.       DAC960_SCSI_Inquiry_T *InquiryStandardData =
  1383. &Controller->V1.InquiryStandardData
  1384. [Controller->V1.DeviceStateChannel]
  1385. [Controller->V1.DeviceStateTargetID];
  1386.       InquiryStandardData->PeripheralDeviceType = 0x1F;
  1387.       Command->V1.CommandMailbox.Type3.CommandOpcode = DAC960_V1_DCDB;
  1388.       Command->V1.CommandMailbox.Type3.BusAddress =
  1389. Virtual_to_Bus32(DCDB);
  1390.       DCDB->Channel = Controller->V1.DeviceStateChannel;
  1391.       DCDB->TargetID = Controller->V1.DeviceStateTargetID;
  1392.       DCDB->Direction = DAC960_V1_DCDB_DataTransferDeviceToSystem;
  1393.       DCDB->EarlyStatus = false;
  1394.       DCDB->Timeout = DAC960_V1_DCDB_Timeout_10_seconds;
  1395.       DCDB->NoAutomaticRequestSense = false;
  1396.       DCDB->DisconnectPermitted = true;
  1397.       DCDB->TransferLength = sizeof(DAC960_SCSI_Inquiry_T);
  1398.       DCDB->BusAddress = Virtual_to_Bus32(InquiryStandardData);
  1399.       DCDB->CDBLength = 6;
  1400.       DCDB->TransferLengthHigh4 = 0;
  1401.       DCDB->SenseLength = sizeof(DCDB->SenseData);
  1402.       DCDB->CDB[0] = 0x12; /* INQUIRY */
  1403.       DCDB->CDB[1] = 0; /* EVPD = 0 */
  1404.       DCDB->CDB[2] = 0; /* Page Code */
  1405.       DCDB->CDB[3] = 0; /* Reserved */
  1406.       DCDB->CDB[4] = sizeof(DAC960_SCSI_Inquiry_T);
  1407.       DCDB->CDB[5] = 0; /* Control */
  1408.       DAC960_QueueCommand(Command);
  1409.       Controller->V1.NeedDeviceInquiryInformation = false;
  1410.       return;
  1411.     }
  1412.   if (Controller->V1.NeedDeviceSerialNumberInformation)
  1413.     {
  1414.       DAC960_V1_DCDB_T *DCDB = &Controller->V1.MonitoringDCDB;
  1415.       DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
  1416. &Controller->V1.InquiryUnitSerialNumber
  1417. [Controller->V1.DeviceStateChannel]
  1418. [Controller->V1.DeviceStateTargetID];
  1419.       InquiryUnitSerialNumber->PeripheralDeviceType = 0x1F;
  1420.       Command->V1.CommandMailbox.Type3.CommandOpcode = DAC960_V1_DCDB;
  1421.       Command->V1.CommandMailbox.Type3.BusAddress =
  1422. Virtual_to_Bus32(DCDB);
  1423.       DCDB->Channel = Controller->V1.DeviceStateChannel;
  1424.       DCDB->TargetID = Controller->V1.DeviceStateTargetID;
  1425.       DCDB->Direction = DAC960_V1_DCDB_DataTransferDeviceToSystem;
  1426.       DCDB->EarlyStatus = false;
  1427.       DCDB->Timeout = DAC960_V1_DCDB_Timeout_10_seconds;
  1428.       DCDB->NoAutomaticRequestSense = false;
  1429.       DCDB->DisconnectPermitted = true;
  1430.       DCDB->TransferLength =
  1431. sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T);
  1432.       DCDB->BusAddress = Virtual_to_Bus32(InquiryUnitSerialNumber);
  1433.       DCDB->CDBLength = 6;
  1434.       DCDB->TransferLengthHigh4 = 0;
  1435.       DCDB->SenseLength = sizeof(DCDB->SenseData);
  1436.       DCDB->CDB[0] = 0x12; /* INQUIRY */
  1437.       DCDB->CDB[1] = 1; /* EVPD = 1 */
  1438.       DCDB->CDB[2] = 0x80; /* Page Code */
  1439.       DCDB->CDB[3] = 0; /* Reserved */
  1440.       DCDB->CDB[4] = sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T);
  1441.       DCDB->CDB[5] = 0; /* Control */
  1442.       DAC960_QueueCommand(Command);
  1443.       Controller->V1.NeedDeviceSerialNumberInformation = false;
  1444.       return;
  1445.     }
  1446.   if (Controller->V1.StartDeviceStateScan)
  1447.     {
  1448.       Controller->V1.DeviceStateChannel = 0;
  1449.       Controller->V1.DeviceStateTargetID = 0;
  1450.       Controller->V1.StartDeviceStateScan = false;
  1451.     }
  1452.   else if (++Controller->V1.DeviceStateTargetID == Controller->Targets)
  1453.     {
  1454.       Controller->V1.DeviceStateChannel++;
  1455.       Controller->V1.DeviceStateTargetID = 0;
  1456.     }
  1457.   if (Controller->V1.DeviceStateChannel < Controller->Channels)
  1458.     {
  1459.       Controller->V1.NewDeviceState.DeviceState =
  1460. DAC960_V1_Device_Dead;
  1461.       Command->V1.CommandMailbox.Type3D.CommandOpcode =
  1462. DAC960_V1_GetDeviceState;
  1463.       Command->V1.CommandMailbox.Type3D.Channel =
  1464. Controller->V1.DeviceStateChannel;
  1465.       Command->V1.CommandMailbox.Type3D.TargetID =
  1466. Controller->V1.DeviceStateTargetID;
  1467.       Command->V1.CommandMailbox.Type3D.BusAddress =
  1468. Virtual_to_Bus32(&Controller->V1.NewDeviceState);
  1469.       DAC960_QueueCommand(Command);
  1470.       return;
  1471.     }
  1472.   Controller->V1.NeedDeviceStateInformation = false;
  1473. }
  1474.       if (Controller->V1.NeedLogicalDriveInformation)
  1475. {
  1476.   Controller->V1.NeedLogicalDriveInformation = false;
  1477.   Command->V1.CommandMailbox.Type3.CommandOpcode =
  1478.     DAC960_V1_GetLogicalDriveInformation;
  1479.   Command->V1.CommandMailbox.Type3.BusAddress =
  1480.     Virtual_to_Bus32(&Controller->V1.NewLogicalDriveInformation);
  1481.   DAC960_QueueCommand(Command);
  1482.   return;
  1483. }
  1484.       if (Controller->V1.NeedRebuildProgress)
  1485. {
  1486.   Controller->V1.NeedRebuildProgress = false;
  1487.   Command->V1.CommandMailbox.Type3.CommandOpcode =
  1488.     DAC960_V1_GetRebuildProgress;
  1489.   Command->V1.CommandMailbox.Type3.BusAddress =
  1490.     Virtual_to_Bus32(&Controller->V1.RebuildProgress);
  1491.   DAC960_QueueCommand(Command);
  1492.   return;
  1493. }
  1494.       if (Controller->V1.NeedConsistencyCheckProgress)
  1495. {
  1496.   Controller->V1.NeedConsistencyCheckProgress = false;
  1497.   Command->V1.CommandMailbox.Type3.CommandOpcode =
  1498.     DAC960_V1_RebuildStat;
  1499.   Command->V1.CommandMailbox.Type3.BusAddress =
  1500.     Virtual_to_Bus32(&Controller->V1.RebuildProgress);
  1501.   DAC960_QueueCommand(Command);
  1502.   return;
  1503. }
  1504.       if (Controller->V1.NeedBackgroundInitializationStatus)
  1505. {
  1506.   Controller->V1.NeedBackgroundInitializationStatus = false;
  1507.   Command->V1.CommandMailbox.Type3B.CommandOpcode =
  1508.     DAC960_V1_BackgroundInitializationControl;
  1509.   Command->V1.CommandMailbox.Type3B.CommandOpcode2 = 0x20;
  1510.   Command->V1.CommandMailbox.Type3B.BusAddress =
  1511.     Virtual_to_Bus32(&Controller->V1.BackgroundInitializationStatus);
  1512.   DAC960_QueueCommand(Command);
  1513.   return;
  1514. }
  1515.       Controller->MonitoringTimerCount++;
  1516.       Controller->MonitoringTimer.expires =
  1517. jiffies + DAC960_MonitoringTimerInterval;
  1518.       add_timer(&Controller->MonitoringTimer);
  1519.     }
  1520.   if (CommandType == DAC960_ImmediateCommand)
  1521.     {
  1522.       complete(Command->Completion);
  1523.       Command->Completion = NULL;
  1524.       return;
  1525.     }
  1526.   if (CommandType == DAC960_QueuedCommand)
  1527.     {
  1528.       DAC960_V1_KernelCommand_T *KernelCommand = Command->V1.KernelCommand;
  1529.       KernelCommand->CommandStatus = Command->V1.CommandStatus;
  1530.       Command->V1.KernelCommand = NULL;
  1531.       if (CommandOpcode == DAC960_V1_DCDB)
  1532. Controller->V1.DirectCommandActive[KernelCommand->DCDB->Channel]
  1533.   [KernelCommand->DCDB->TargetID] =
  1534.   false;
  1535.       DAC960_DeallocateCommand(Command);
  1536.       KernelCommand->CompletionFunction(KernelCommand);
  1537.       return;
  1538.     }
  1539.   /*
  1540.     Queue a Status Monitoring Command to the Controller using the just
  1541.     completed Command if one was deferred previously due to lack of a
  1542.     free Command when the Monitoring Timer Function was called.
  1543.   */
  1544.   if (Controller->MonitoringCommandDeferred)
  1545.     {
  1546.       Controller->MonitoringCommandDeferred = false;
  1547.       DAC960_V1_QueueMonitoringCommand(Command);
  1548.       return;
  1549.     }
  1550.   /*
  1551.     Deallocate the Command.
  1552.   */
  1553.   DAC960_DeallocateCommand(Command);
  1554.   /*
  1555.     Wake up any processes waiting on a free Command.
  1556.   */
  1557.   wake_up(&Controller->CommandWaitQueue);
  1558. }
  1561. /*
  1562.   DAC960_V2_ReadWriteError prints an appropriate error message for Command
  1563.   when an error occurs on a Read or Write operation.
  1564. */
  1566. static void DAC960_V2_ReadWriteError(DAC960_Command_T *Command)
  1567. {
  1568.   DAC960_Controller_T *Controller = Command->Controller;
  1569.   unsigned char *SenseErrors[] = { "NO SENSE", "RECOVERED ERROR",
  1570.    "NOT READY", "MEDIUM ERROR",
  1571.    "HARDWARE ERROR", "ILLEGAL REQUEST",
  1572.    "UNIT ATTENTION", "DATA PROTECT",
  1573.    "BLANK CHECK", "VENDOR-SPECIFIC",
  1574.    "COPY ABORTED", "ABORTED COMMAND",
  1575.    "EQUAL", "VOLUME OVERFLOW",
  1576.    "MISCOMPARE", "RESERVED" };
  1577.   unsigned char *CommandName = "UNKNOWN";
  1578.   switch (Command->CommandType)
  1579.     {
  1580.     case DAC960_ReadCommand:
  1581.     case DAC960_ReadRetryCommand:
  1582.       CommandName = "READ";
  1583.       break;
  1584.     case DAC960_WriteCommand:
  1585.     case DAC960_WriteRetryCommand:
  1586.       CommandName = "WRITE";
  1587.       break;
  1588.     case DAC960_MonitoringCommand:
  1589.     case DAC960_ImmediateCommand:
  1590.     case DAC960_QueuedCommand:
  1591.       break;
  1592.     }
  1593.   DAC960_Error("Error Condition %s on %s:n", Controller,
  1594.        SenseErrors[Command->V2.RequestSense.SenseKey], CommandName);
  1595.   DAC960_Error("  /dev/rd/c%dd%d:   absolute blocks %u..%un",
  1596.        Controller, Controller->ControllerNumber,
  1597.        Command->LogicalDriveNumber, Command->BlockNumber,
  1598.        Command->BlockNumber + Command->BlockCount - 1);
  1599.   if (DAC960_PartitionNumber(Command->BufferHeader->b_rdev) > 0)
  1600.     DAC960_Error("  /dev/rd/c%dd%dp%d: relative blocks %u..%un",
  1601.  Controller, Controller->ControllerNumber,
  1602.  Command->LogicalDriveNumber,
  1603.  DAC960_PartitionNumber(Command->BufferHeader->b_rdev),
  1604.  Command->BufferHeader->b_rsector,
  1605.  Command->BufferHeader->b_rsector + Command->BlockCount - 1);
  1606. }
  1609. /*
  1610.   DAC960_V2_ReportEvent prints an appropriate message when a Controller Event
  1611.   occurs.
  1612. */
  1614. static void DAC960_V2_ReportEvent(DAC960_Controller_T *Controller,
  1615.   DAC960_V2_Event_T *Event)
  1616. {
  1617.   DAC960_SCSI_RequestSense_T *RequestSense =
  1618.     (DAC960_SCSI_RequestSense_T *) &Event->RequestSenseData;
  1619.   unsigned char MessageBuffer[DAC960_LineBufferSize];
  1620.   static struct { int EventCode; unsigned char *EventMessage; } EventList[] =
  1621.     { /* Physical Device Events (0x0000 - 0x007F) */
  1622.       { 0x0001, "P Online" },
  1623.       { 0x0002, "P Standby" },
  1624.       { 0x0005, "P Automatic Rebuild Started" },
  1625.       { 0x0006, "P Manual Rebuild Started" },
  1626.       { 0x0007, "P Rebuild Completed" },
  1627.       { 0x0008, "P Rebuild Cancelled" },
  1628.       { 0x0009, "P Rebuild Failed for Unknown Reasons" },
  1629.       { 0x000A, "P Rebuild Failed due to New Physical Device" },
  1630.       { 0x000B, "P Rebuild Failed due to Logical Drive Failure" },
  1631.       { 0x000C, "S Offline" },
  1632.       { 0x000D, "P Found" },
  1633.       { 0x000E, "P Removed" },
  1634.       { 0x000F, "P Unconfigured" },
  1635.       { 0x0010, "P Expand Capacity Started" },
  1636.       { 0x0011, "P Expand Capacity Completed" },
  1637.       { 0x0012, "P Expand Capacity Failed" },
  1638.       { 0x0013, "P Command Timed Out" },
  1639.       { 0x0014, "P Command Aborted" },
  1640.       { 0x0015, "P Command Retried" },
  1641.       { 0x0016, "P Parity Error" },
  1642.       { 0x0017, "P Soft Error" },
  1643.       { 0x0018, "P Miscellaneous Error" },
  1644.       { 0x0019, "P Reset" },
  1645.       { 0x001A, "P Active Spare Found" },
  1646.       { 0x001B, "P Warm Spare Found" },
  1647.       { 0x001C, "S Sense Data Received" },
  1648.       { 0x001D, "P Initialization Started" },
  1649.       { 0x001E, "P Initialization Completed" },
  1650.       { 0x001F, "P Initialization Failed" },
  1651.       { 0x0020, "P Initialization Cancelled" },
  1652.       { 0x0021, "P Failed because Write Recovery Failed" },
  1653.       { 0x0022, "P Failed because SCSI Bus Reset Failed" },
  1654.       { 0x0023, "P Failed because of Double Check Condition" },
  1655.       { 0x0024, "P Failed because Device Cannot Be Accessed" },
  1656.       { 0x0025, "P Failed because of Gross Error on SCSI Processor" },
  1657.       { 0x0026, "P Failed because of Bad Tag from Device" },
  1658.       { 0x0027, "P Failed because of Command Timeout" },
  1659.       { 0x0028, "P Failed because of System Reset" },
  1660.       { 0x0029, "P Failed because of Busy Status or Parity Error" },
  1661.       { 0x002A, "P Failed because Host Set Device to Failed State" },
  1662.       { 0x002B, "P Failed because of Selection Timeout" },
  1663.       { 0x002C, "P Failed because of SCSI Bus Phase Error" },
  1664.       { 0x002D, "P Failed because Device Returned Unknown Status" },
  1665.       { 0x002E, "P Failed because Device Not Ready" },
  1666.       { 0x002F, "P Failed because Device Not Found at Startup" },
  1667.       { 0x0030, "P Failed because COD Write Operation Failed" },
  1668.       { 0x0031, "P Failed because BDT Write Operation Failed" },
  1669.       { 0x0039, "P Missing at Startup" },
  1670.       { 0x003A, "P Start Rebuild Failed due to Physical Drive Too Small" },
  1671.       { 0x003C, "P Temporarily Offline Device Automatically Made Online" },
  1672.       { 0x003D, "P Standby Rebuild Started" },
  1673.       /* Logical Device Events (0x0080 - 0x00FF) */
  1674.       { 0x0080, "M Consistency Check Started" },
  1675.       { 0x0081, "M Consistency Check Completed" },
  1676.       { 0x0082, "M Consistency Check Cancelled" },
  1677.       { 0x0083, "M Consistency Check Completed With Errors" },
  1678.       { 0x0084, "M Consistency Check Failed due to Logical Drive Failure" },
  1679.       { 0x0085, "M Consistency Check Failed due to Physical Device Failure" },
  1680.       { 0x0086, "L Offline" },
  1681.       { 0x0087, "L Critical" },
  1682.       { 0x0088, "L Online" },
  1683.       { 0x0089, "M Automatic Rebuild Started" },
  1684.       { 0x008A, "M Manual Rebuild Started" },
  1685.       { 0x008B, "M Rebuild Completed" },
  1686.       { 0x008C, "M Rebuild Cancelled" },
  1687.       { 0x008D, "M Rebuild Failed for Unknown Reasons" },
  1688.       { 0x008E, "M Rebuild Failed due to New Physical Device" },
  1689.       { 0x008F, "M Rebuild Failed due to Logical Drive Failure" },
  1690.       { 0x0090, "M Initialization Started" },
  1691.       { 0x0091, "M Initialization Completed" },
  1692.       { 0x0092, "M Initialization Cancelled" },
  1693.       { 0x0093, "M Initialization Failed" },
  1694.       { 0x0094, "L Found" },
  1695.       { 0x0095, "L Deleted" },
  1696.       { 0x0096, "M Expand Capacity Started" },
  1697.       { 0x0097, "M Expand Capacity Completed" },
  1698.       { 0x0098, "M Expand Capacity Failed" },
  1699.       { 0x0099, "L Bad Block Found" },
  1700.       { 0x009A, "L Size Changed" },
  1701.       { 0x009B, "L Type Changed" },
  1702.       { 0x009C, "L Bad Data Block Found" },
  1703.       { 0x009E, "L Read of Data Block in BDT" },
  1704.       { 0x009F, "L Write Back Data for Disk Block Lost" },
  1705.       { 0x00A0, "L Temporarily Offline RAID-5/3 Drive Made Online" },
  1706.       { 0x00A1, "L Temporarily Offline RAID-6/1/0/7 Drive Made Online" },
  1707.       { 0x00A2, "L Standby Rebuild Started" },
  1708.       /* Fault Management Events (0x0100 - 0x017F) */
  1709.       { 0x0140, "E Fan %d Failed" },
  1710.       { 0x0141, "E Fan %d OK" },
  1711.       { 0x0142, "E Fan %d Not Present" },
  1712.       { 0x0143, "E Power Supply %d Failed" },
  1713.       { 0x0144, "E Power Supply %d OK" },
  1714.       { 0x0145, "E Power Supply %d Not Present" },
  1715.       { 0x0146, "E Temperature Sensor %d Temperature Exceeds Safe Limit" },
  1716.       { 0x0147, "E Temperature Sensor %d Temperature Exceeds Working Limit" },
  1717.       { 0x0148, "E Temperature Sensor %d Temperature Normal" },
  1718.       { 0x0149, "E Temperature Sensor %d Not Present" },
  1719.       { 0x014A, "E Enclosure Management Unit %d Access Critical" },
  1720.       { 0x014B, "E Enclosure Management Unit %d Access OK" },
  1721.       { 0x014C, "E Enclosure Management Unit %d Access Offline" },
  1722.       /* Controller Events (0x0180 - 0x01FF) */
  1723.       { 0x0181, "C Cache Write Back Error" },
  1724.       { 0x0188, "C Battery Backup Unit Found" },
  1725.       { 0x0189, "C Battery Backup Unit Charge Level Low" },
  1726.       { 0x018A, "C Battery Backup Unit Charge Level OK" },
  1727.       { 0x0193, "C Installation Aborted" },
  1728.       { 0x0195, "C Battery Backup Unit Physically Removed" },
  1729.       { 0x0196, "C Memory Error During Warm Boot" },
  1730.       { 0x019E, "C Memory Soft ECC Error Corrected" },
  1731.       { 0x019F, "C Memory Hard ECC Error Corrected" },
  1732.       { 0x01A2, "C Battery Backup Unit Failed" },
  1733.       { 0x01AB, "C Mirror Race Recovery Failed" },
  1734.       { 0x01AC, "C Mirror Race on Critical Drive" },
  1735.       /* Controller Internal Processor Events */
  1736.       { 0x0380, "C Internal Controller Hung" },
  1737.       { 0x0381, "C Internal Controller Firmware Breakpoint" },
  1738.       { 0x0390, "C Internal Controller i960 Processor Specific Error" },
  1739.       { 0x03A0, "C Internal Controller StrongARM Processor Specific Error" },
  1740.       { 0, "" } };
  1741.   int EventListIndex = 0, EventCode;
  1742.   unsigned char EventType, *EventMessage;
  1743.   if (Event->EventCode == 0x1C &&
  1744.       RequestSense->SenseKey == DAC960_SenseKey_VendorSpecific &&
  1745.       (RequestSense->AdditionalSenseCode == 0x80 ||
  1746.        RequestSense->AdditionalSenseCode == 0x81))
  1747.     Event->EventCode = ((RequestSense->AdditionalSenseCode - 0x80) << 8) |
  1748.        RequestSense->AdditionalSenseCodeQualifier;
  1749.   while (true)
  1750.     {
  1751.       EventCode = EventList[EventListIndex].EventCode;
  1752.       if (EventCode == Event->EventCode || EventCode == 0) break;
  1753.       EventListIndex++;
  1754.     }
  1755.   EventType = EventList[EventListIndex].EventMessage[0];
  1756.   EventMessage = &EventList[EventListIndex].EventMessage[2];
  1757.   if (EventCode == 0)
  1758.     {
  1759.       DAC960_Critical("Unknown Controller Event Code %04Xn",
  1760.       Controller, Event->EventCode);
  1761.       return;
  1762.     }
  1763.   switch (EventType)
  1764.     {
  1765.     case 'P':
  1766.       DAC960_Critical("Physical Device %d:%d %sn", Controller,
  1767.       Event->Channel, Event->TargetID, EventMessage);
  1768.       break;
  1769.     case 'L':
  1770.       DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) %sn", Controller,
  1771.       Event->LogicalUnit, Controller->ControllerNumber,
  1772.       Event->LogicalUnit, EventMessage);
  1773.       break;
  1774.     case 'M':
  1775.       DAC960_Progress("Logical Drive %d (/dev/rd/c%dd%d) %sn", Controller,
  1776.       Event->LogicalUnit, Controller->ControllerNumber,
  1777.       Event->LogicalUnit, EventMessage);
  1778.       break;
  1779.     case 'S':
  1780.       if (RequestSense->SenseKey == DAC960_SenseKey_NoSense ||
  1781.   (RequestSense->SenseKey == DAC960_SenseKey_NotReady &&
  1782.    RequestSense->AdditionalSenseCode == 0x04 &&
  1783.    (RequestSense->AdditionalSenseCodeQualifier == 0x01 ||
  1784.     RequestSense->AdditionalSenseCodeQualifier == 0x02)))
  1785. break;
  1786.       DAC960_Critical("Physical Device %d:%d %sn", Controller,
  1787.       Event->Channel, Event->TargetID, EventMessage);
  1788.       DAC960_Critical("Physical Device %d:%d Request Sense: "
  1789.       "Sense Key = %X, ASC = %02X, ASCQ = %02Xn",
  1790.       Controller,
  1791.       Event->Channel,
  1792.       Event->TargetID,
  1793.       RequestSense->SenseKey,
  1794.       RequestSense->AdditionalSenseCode,
  1795.       RequestSense->AdditionalSenseCodeQualifier);
  1796.       DAC960_Critical("Physical Device %d:%d Request Sense: "
  1797.       "Information = %02X%02X%02X%02X "
  1798.       "%02X%02X%02X%02Xn",
  1799.       Controller,
  1800.       Event->Channel,
  1801.       Event->TargetID,
  1802.       RequestSense->Information[0],
  1803.       RequestSense->Information[1],
  1804.       RequestSense->Information[2],
  1805.       RequestSense->Information[3],
  1806.       RequestSense->CommandSpecificInformation[0],
  1807.       RequestSense->CommandSpecificInformation[1],
  1808.       RequestSense->CommandSpecificInformation[2],
  1809.       RequestSense->CommandSpecificInformation[3]);
  1810.       break;
  1811.     case 'E':
  1812.       if (Controller->SuppressEnclosureMessages) break;
  1813.       sprintf(MessageBuffer, EventMessage, Event->LogicalUnit);
  1814.       DAC960_Critical("Enclosure %d %sn", Controller,
  1815.       Event->TargetID, MessageBuffer);
  1816.       break;
  1817.     case 'C':
  1818.       DAC960_Critical("Controller %sn", Controller, EventMessage);
  1819.       break;
  1820.     default:
  1821.       DAC960_Critical("Unknown Controller Event Code %04Xn",
  1822.       Controller, Event->EventCode);
  1823.       break;
  1824.     }
  1825. }
  1828. /*
  1829.   DAC960_V2_ReportProgress prints an appropriate progress message for
  1830.   Logical Device Long Operations.
  1831. */
  1833. static void DAC960_V2_ReportProgress(DAC960_Controller_T *Controller,
  1834.      unsigned char *MessageString,
  1835.      unsigned int LogicalDeviceNumber,
  1836.      unsigned long BlocksCompleted,
  1837.      unsigned long LogicalDeviceSize)
  1838. {
  1839.   Controller->EphemeralProgressMessage = true;
  1840.   DAC960_Progress("%s in Progress: Logical Drive %d (/dev/rd/c%dd%d) "
  1841.   "%d%% completedn", Controller,
  1842.   MessageString,
  1843.   LogicalDeviceNumber,
  1844.   Controller->ControllerNumber,
  1845.   LogicalDeviceNumber,
  1846.   (100 * (BlocksCompleted >> 7)) / (LogicalDeviceSize >> 7));
  1847.   Controller->EphemeralProgressMessage = false;
  1848. }
  1851. /*
  1852.   DAC960_V2_ProcessCompletedCommand performs completion processing for Command
  1853.   for DAC960 V2 Firmware Controllers.
  1854. */
  1856. static void DAC960_V2_ProcessCompletedCommand(DAC960_Command_T *Command)
  1857. {
  1858.   DAC960_Controller_T *Controller = Command->Controller;
  1859.   DAC960_CommandType_T CommandType = Command->CommandType;
  1860.   DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
  1861.   DAC960_V2_IOCTL_Opcode_T CommandOpcode = CommandMailbox->Common.IOCTL_Opcode;
  1862.   DAC960_V2_CommandStatus_T CommandStatus = Command->V2.CommandStatus;
  1863.   BufferHeader_T *BufferHeader = Command->BufferHeader;
  1864.   if (CommandType == DAC960_ReadCommand ||
  1865.       CommandType == DAC960_WriteCommand)
  1866.     {
  1867.       if (CommandStatus == DAC960_V2_NormalCompletion)
  1868. {
  1869.   /*
  1870.     Perform completion processing for all buffers in this I/O Request.
  1871.   */
  1872.   while (BufferHeader != NULL)
  1873.     {
  1874.       BufferHeader_T *NextBufferHeader = BufferHeader->b_reqnext;
  1875.       BufferHeader->b_reqnext = NULL;
  1876.       DAC960_ProcessCompletedBuffer(BufferHeader, true);
  1877.       BufferHeader = NextBufferHeader;
  1878.     }
  1879.   if (Command->Completion != NULL)
  1880.     {
  1881.       complete(Command->Completion);
  1882.       Command->Completion = NULL;
  1883.     }
  1884.   add_blkdev_randomness(DAC960_MAJOR + Controller->ControllerNumber);
  1885. }
  1886.       else if (Command->V2.RequestSense.SenseKey
  1887.        == DAC960_SenseKey_MediumError &&
  1888.        BufferHeader != NULL &&
  1889.        BufferHeader->b_reqnext != NULL)
  1890. {
  1891.   if (CommandType == DAC960_ReadCommand)
  1892.     Command->CommandType = DAC960_ReadRetryCommand;
  1893.   else Command->CommandType = DAC960_WriteRetryCommand;
  1894.   Command->BlockCount = BufferHeader->b_size >> DAC960_BlockSizeBits;
  1895.   CommandMailbox->SCSI_10.CommandControlBits
  1896.  .AdditionalScatterGatherListMemory = false;
  1897.   CommandMailbox->SCSI_10.DataTransferSize =
  1898.     Command->BlockCount << DAC960_BlockSizeBits;
  1899.   CommandMailbox->SCSI_10.DataTransferMemoryAddress
  1900.  .ScatterGatherSegments[0].SegmentDataPointer =
  1901.     Virtual_to_Bus64(BufferHeader->b_data);
  1902.   CommandMailbox->SCSI_10.DataTransferMemoryAddress
  1903.  .ScatterGatherSegments[0].SegmentByteCount =
  1904.     CommandMailbox->SCSI_10.DataTransferSize;
  1905.   CommandMailbox->SCSI_10.SCSI_CDB[7] = Command->BlockCount >> 8;
  1906.   CommandMailbox->SCSI_10.SCSI_CDB[8] = Command->BlockCount;
  1907.   DAC960_QueueCommand(Command);
  1908.   return;
  1909. }
  1910.       else
  1911. {
  1912.   if (Command->V2.RequestSense.SenseKey != DAC960_SenseKey_NotReady)
  1913.     DAC960_V2_ReadWriteError(Command);
  1914.   /*
  1915.     Perform completion processing for all buffers in this I/O Request.
  1916.   */
  1917.   while (BufferHeader != NULL)
  1918.     {
  1919.       BufferHeader_T *NextBufferHeader = BufferHeader->b_reqnext;
  1920.       BufferHeader->b_reqnext = NULL;
  1921.       DAC960_ProcessCompletedBuffer(BufferHeader, false);
  1922.       BufferHeader = NextBufferHeader;
  1923.     }
  1924.   if (Command->Completion != NULL)
  1925.     {
  1926.       complete(Command->Completion);
  1927.       Command->Completion = NULL;
  1928.     }
  1929. }
  1930.     }
  1931.   else if (CommandType == DAC960_ReadRetryCommand ||
  1932.    CommandType == DAC960_WriteRetryCommand)
  1933.     {
  1934.       BufferHeader_T *NextBufferHeader = BufferHeader->b_reqnext;
  1935.       BufferHeader->b_reqnext = NULL;
  1936.       /*
  1937. Perform completion processing for this single buffer.
  1938.       */
  1939.       if (CommandStatus == DAC960_V2_NormalCompletion)
  1940. DAC960_ProcessCompletedBuffer(BufferHeader, true);
  1941.       else
  1942. {
  1943.   if (Command->V2.RequestSense.SenseKey != DAC960_SenseKey_NotReady)
  1944.     DAC960_V2_ReadWriteError(Command);
  1945.   DAC960_ProcessCompletedBuffer(BufferHeader, false);
  1946. }
  1947.       if (NextBufferHeader != NULL)
  1948. {
  1949.   Command->BlockNumber +=
  1950.     BufferHeader->b_size >> DAC960_BlockSizeBits;
  1951.   Command->BlockCount =
  1952.     NextBufferHeader->b_size >> DAC960_BlockSizeBits;
  1953.   Command->BufferHeader = NextBufferHeader;
  1954.   CommandMailbox->SCSI_10.DataTransferSize =
  1955.     Command->BlockCount << DAC960_BlockSizeBits;
  1956.   CommandMailbox->SCSI_10.DataTransferMemoryAddress
  1957.  .ScatterGatherSegments[0]
  1958.  .SegmentDataPointer =
  1959.     Virtual_to_Bus64(NextBufferHeader->b_data);
  1960.   CommandMailbox->SCSI_10.DataTransferMemoryAddress
  1961.  .ScatterGatherSegments[0]
  1962.  .SegmentByteCount =
  1963.     CommandMailbox->SCSI_10.DataTransferSize;
  1964.   CommandMailbox->SCSI_10.SCSI_CDB[2] = Command->BlockNumber >> 24;
  1965.   CommandMailbox->SCSI_10.SCSI_CDB[3] = Command->BlockNumber >> 16;
  1966.   CommandMailbox->SCSI_10.SCSI_CDB[4] = Command->BlockNumber >> 8;
  1967.   CommandMailbox->SCSI_10.SCSI_CDB[5] = Command->BlockNumber;
  1968.   CommandMailbox->SCSI_10.SCSI_CDB[7] = Command->BlockCount >> 8;
  1969.   CommandMailbox->SCSI_10.SCSI_CDB[8] = Command->BlockCount;
  1970.   DAC960_QueueCommand(Command);
  1971.   return;
  1972. }
  1973.     }
  1974.   else if (CommandType == DAC960_MonitoringCommand)
  1975.     {
  1976.       if (CommandOpcode == DAC960_V2_GetControllerInfo)
  1977. {
  1978.   DAC960_V2_ControllerInfo_T *NewControllerInfo =
  1979.     &Controller->V2.NewControllerInformation;
  1980.   DAC960_V2_ControllerInfo_T *ControllerInfo =
  1981.     &Controller->V2.ControllerInformation;
  1982.   Controller->LogicalDriveCount =
  1983.     NewControllerInfo->LogicalDevicesPresent;
  1984.   Controller->V2.NeedLogicalDeviceInformation = true;
  1985.   Controller->V2.NeedPhysicalDeviceInformation = true;
  1986.   Controller->V2.StartLogicalDeviceInformationScan = true;
  1987.   Controller->V2.StartPhysicalDeviceInformationScan = true;
  1988.   Controller->MonitoringAlertMode =
  1989.     (NewControllerInfo->LogicalDevicesCritical > 0 ||
  1990.      NewControllerInfo->LogicalDevicesOffline > 0 ||
  1991.      NewControllerInfo->PhysicalDisksCritical > 0 ||
  1992.      NewControllerInfo->PhysicalDisksOffline > 0);
  1993.   memcpy(ControllerInfo, NewControllerInfo,
  1994.  sizeof(DAC960_V2_ControllerInfo_T));
  1995. }
  1996.       else if (CommandOpcode == DAC960_V2_GetEvent)
  1997. {
  1998.   if (CommandStatus == DAC960_V2_NormalCompletion)
  1999.     DAC960_V2_ReportEvent(Controller, &Controller->V2.Event);
  2000.   Controller->V2.NextEventSequenceNumber++;
  2001. }
  2002.       else if (CommandOpcode == DAC960_V2_GetPhysicalDeviceInfoValid &&
  2003.        CommandStatus == DAC960_V2_NormalCompletion)
  2004. {
  2005.   DAC960_V2_PhysicalDeviceInfo_T *NewPhysicalDeviceInfo =
  2006.     &Controller->V2.NewPhysicalDeviceInformation;
  2007.   unsigned int PhysicalDeviceIndex = Controller->V2.PhysicalDeviceIndex;
  2008.   DAC960_V2_PhysicalDeviceInfo_T *PhysicalDeviceInfo =
  2009.     Controller->V2.PhysicalDeviceInformation[PhysicalDeviceIndex];
  2010.   DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
  2011.     Controller->V2.InquiryUnitSerialNumber[PhysicalDeviceIndex];
  2012.   unsigned int DeviceIndex;
  2013.   while (PhysicalDeviceInfo != NULL &&
  2014.  (NewPhysicalDeviceInfo->Channel >
  2015.   PhysicalDeviceInfo->Channel ||
  2016.   (NewPhysicalDeviceInfo->Channel ==
  2017.    PhysicalDeviceInfo->Channel &&
  2018.    (NewPhysicalDeviceInfo->TargetID >
  2019.     PhysicalDeviceInfo->TargetID ||
  2020.    (NewPhysicalDeviceInfo->TargetID ==
  2021.     PhysicalDeviceInfo->TargetID &&
  2022.     NewPhysicalDeviceInfo->LogicalUnit >
  2023.     PhysicalDeviceInfo->LogicalUnit)))))
  2024.     {
  2025.       DAC960_Critical("Physical Device %d:%d No Longer Existsn",
  2026.       Controller,
  2027.       PhysicalDeviceInfo->Channel,
  2028.       PhysicalDeviceInfo->TargetID);
  2029.       Controller->V2.PhysicalDeviceInformation
  2030.      [PhysicalDeviceIndex] = NULL;
  2031.       Controller->V2.InquiryUnitSerialNumber
  2032.      [PhysicalDeviceIndex] = NULL;
  2033.       kfree(PhysicalDeviceInfo);
  2034.       kfree(InquiryUnitSerialNumber);
  2035.       for (DeviceIndex = PhysicalDeviceIndex;
  2036.    DeviceIndex < DAC960_V2_MaxPhysicalDevices - 1;
  2037.    DeviceIndex++)
  2038. {
  2039.   Controller->V2.PhysicalDeviceInformation[DeviceIndex] =
  2040.     Controller->V2.PhysicalDeviceInformation[DeviceIndex+1];
  2041.   Controller->V2.InquiryUnitSerialNumber[DeviceIndex] =
  2042.     Controller->V2.InquiryUnitSerialNumber[DeviceIndex+1];
  2043. }
  2044.       Controller->V2.PhysicalDeviceInformation
  2045.      [DAC960_V2_MaxPhysicalDevices-1] = NULL;
  2046.       Controller->V2.InquiryUnitSerialNumber
  2047.      [DAC960_V2_MaxPhysicalDevices-1] = NULL;
  2048.       PhysicalDeviceInfo =
  2049. Controller->V2.PhysicalDeviceInformation[PhysicalDeviceIndex];
  2050.       InquiryUnitSerialNumber =
  2051. Controller->V2.InquiryUnitSerialNumber[PhysicalDeviceIndex];
  2052.     }
  2053.   if (PhysicalDeviceInfo == NULL ||
  2054.       (NewPhysicalDeviceInfo->Channel !=
  2055.        PhysicalDeviceInfo->Channel) ||
  2056.       (NewPhysicalDeviceInfo->TargetID !=
  2057.        PhysicalDeviceInfo->TargetID) ||
  2058.       (NewPhysicalDeviceInfo->LogicalUnit !=
  2059.        PhysicalDeviceInfo->LogicalUnit))
  2060.     {
  2061.       PhysicalDeviceInfo = (DAC960_V2_PhysicalDeviceInfo_T *)
  2062. kmalloc(sizeof(DAC960_V2_PhysicalDeviceInfo_T), GFP_ATOMIC);
  2063.       InquiryUnitSerialNumber =
  2064. (DAC960_SCSI_Inquiry_UnitSerialNumber_T *)
  2065.   kmalloc(sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T),
  2066.   GFP_ATOMIC);
  2067.       if (InquiryUnitSerialNumber == NULL &&
  2068.   PhysicalDeviceInfo != NULL)
  2069. {
  2070.   kfree(PhysicalDeviceInfo);
  2071.   PhysicalDeviceInfo = NULL;
  2072. }
  2073.       DAC960_Critical("Physical Device %d:%d Now Exists%sn",
  2074.       Controller,
  2075.       NewPhysicalDeviceInfo->Channel,
  2076.       NewPhysicalDeviceInfo->TargetID,
  2077.       (PhysicalDeviceInfo != NULL
  2078.        ? "" : " - Allocation Failed"));
  2079.       if (PhysicalDeviceInfo != NULL)
  2080. {
  2081.   memset(PhysicalDeviceInfo, 0,
  2082.  sizeof(DAC960_V2_PhysicalDeviceInfo_T));
  2083.   PhysicalDeviceInfo->PhysicalDeviceState =
  2084.     DAC960_V2_Device_InvalidState;
  2085.   memset(InquiryUnitSerialNumber, 0,
  2086.  sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
  2087.   InquiryUnitSerialNumber->PeripheralDeviceType = 0x1F;
  2088.   for (DeviceIndex = DAC960_V2_MaxPhysicalDevices - 1;
  2089.        DeviceIndex > PhysicalDeviceIndex;
  2090.        DeviceIndex--)
  2091.     {
  2092.       Controller->V2.PhysicalDeviceInformation[DeviceIndex] =
  2093. Controller->V2.PhysicalDeviceInformation[DeviceIndex-1];
  2094.       Controller->V2.InquiryUnitSerialNumber[DeviceIndex] =
  2095. Controller->V2.InquiryUnitSerialNumber[DeviceIndex-1];
  2096.     }
  2097.   Controller->V2.PhysicalDeviceInformation
  2098.  [PhysicalDeviceIndex] =
  2099.     PhysicalDeviceInfo;
  2100.   Controller->V2.InquiryUnitSerialNumber
  2101.  [PhysicalDeviceIndex] =
  2102.     InquiryUnitSerialNumber;
  2103.   Controller->V2.NeedDeviceSerialNumberInformation = true;
  2104. }
  2105.     }
  2106.   if (PhysicalDeviceInfo != NULL)
  2107.     {
  2108.       if (NewPhysicalDeviceInfo->PhysicalDeviceState !=
  2109.   PhysicalDeviceInfo->PhysicalDeviceState)
  2110. DAC960_Critical(
  2111.   "Physical Device %d:%d is now %sn", Controller,
  2112.   NewPhysicalDeviceInfo->Channel,
  2113.   NewPhysicalDeviceInfo->TargetID,
  2114.   (NewPhysicalDeviceInfo->PhysicalDeviceState
  2115.    == DAC960_V2_Device_Online
  2116.    ? "ONLINE"
  2117.    : NewPhysicalDeviceInfo->PhysicalDeviceState
  2118.      == DAC960_V2_Device_Rebuild
  2119.      ? "REBUILD"
  2120.      : NewPhysicalDeviceInfo->PhysicalDeviceState
  2121.        == DAC960_V2_Device_Missing
  2122.        ? "MISSING"
  2123.        : NewPhysicalDeviceInfo->PhysicalDeviceState
  2124.  == DAC960_V2_Device_Critical
  2125.  ? "CRITICAL"
  2126.  : NewPhysicalDeviceInfo->PhysicalDeviceState
  2127.    == DAC960_V2_Device_Dead
  2128.    ? "DEAD"
  2129.    : NewPhysicalDeviceInfo->PhysicalDeviceState
  2130.      == DAC960_V2_Device_SuspectedDead
  2131.      ? "SUSPECTED-DEAD"
  2132.      : NewPhysicalDeviceInfo->PhysicalDeviceState
  2133.        == DAC960_V2_Device_CommandedOffline
  2134.        ? "COMMANDED-OFFLINE"
  2135.        : NewPhysicalDeviceInfo->PhysicalDeviceState
  2136.  == DAC960_V2_Device_Standby
  2137.  ? "STANDBY" : "UNKNOWN"));
  2138.       if ((NewPhysicalDeviceInfo->ParityErrors !=
  2139.    PhysicalDeviceInfo->ParityErrors) ||
  2140.   (NewPhysicalDeviceInfo->SoftErrors !=
  2141.    PhysicalDeviceInfo->SoftErrors) ||
  2142.   (NewPhysicalDeviceInfo->HardErrors !=
  2143.    PhysicalDeviceInfo->HardErrors) ||
  2144.   (NewPhysicalDeviceInfo->MiscellaneousErrors !=
  2145.    PhysicalDeviceInfo->MiscellaneousErrors) ||
  2146.   (NewPhysicalDeviceInfo->CommandTimeouts !=
  2147.    PhysicalDeviceInfo->CommandTimeouts) ||
  2148.   (NewPhysicalDeviceInfo->Retries !=
  2149.    PhysicalDeviceInfo->Retries) ||
  2150.   (NewPhysicalDeviceInfo->Aborts !=
  2151.    PhysicalDeviceInfo->Aborts) ||
  2152.   (NewPhysicalDeviceInfo->PredictedFailuresDetected !=
  2153.    PhysicalDeviceInfo->PredictedFailuresDetected))
  2154. {
  2155.   DAC960_Critical("Physical Device %d:%d Errors: "
  2156.   "Parity = %d, Soft = %d, "
  2157.   "Hard = %d, Misc = %dn",
  2158.   Controller,
  2159.   NewPhysicalDeviceInfo->Channel,
  2160.   NewPhysicalDeviceInfo->TargetID,
  2161.   NewPhysicalDeviceInfo->ParityErrors,
  2162.   NewPhysicalDeviceInfo->SoftErrors,
  2163.   NewPhysicalDeviceInfo->HardErrors,
  2164.   NewPhysicalDeviceInfo->MiscellaneousErrors);
  2165.   DAC960_Critical("Physical Device %d:%d Errors: "
  2166.   "Timeouts = %d, Retries = %d, "
  2167.   "Aborts = %d, Predicted = %dn",
  2168.   Controller,
  2169.   NewPhysicalDeviceInfo->Channel,
  2170.   NewPhysicalDeviceInfo->TargetID,
  2171.   NewPhysicalDeviceInfo->CommandTimeouts,
  2172.   NewPhysicalDeviceInfo->Retries,
  2173.   NewPhysicalDeviceInfo->Aborts,
  2174.   NewPhysicalDeviceInfo
  2175.   ->PredictedFailuresDetected);
  2176. }
  2177.       if ((PhysicalDeviceInfo->PhysicalDeviceState
  2178.    == DAC960_V2_Device_Dead ||
  2179.    PhysicalDeviceInfo->PhysicalDeviceState
  2180.    == DAC960_V2_Device_InvalidState) &&
  2181.   NewPhysicalDeviceInfo->PhysicalDeviceState
  2182.   != DAC960_V2_Device_Dead)
  2183. Controller->V2.NeedDeviceSerialNumberInformation = true;
  2184.       memcpy(PhysicalDeviceInfo, NewPhysicalDeviceInfo,
  2185.      sizeof(DAC960_V2_PhysicalDeviceInfo_T));
  2186.     }
  2187.   NewPhysicalDeviceInfo->LogicalUnit++;
  2188.   Controller->V2.PhysicalDeviceIndex++;
  2189. }
  2190.       else if (CommandOpcode == DAC960_V2_GetPhysicalDeviceInfoValid)
  2191. {
  2192.   unsigned int DeviceIndex;
  2193.   for (DeviceIndex = Controller->V2.PhysicalDeviceIndex;
  2194.        DeviceIndex < DAC960_V2_MaxPhysicalDevices;
  2195.        DeviceIndex++)
  2196.     {
  2197.       DAC960_V2_PhysicalDeviceInfo_T *PhysicalDeviceInfo =
  2198. Controller->V2.PhysicalDeviceInformation[DeviceIndex];
  2199.       DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
  2200. Controller->V2.InquiryUnitSerialNumber[DeviceIndex];
  2201.       if (PhysicalDeviceInfo == NULL) break;
  2202.       DAC960_Critical("Physical Device %d:%d No Longer Existsn",
  2203.       Controller,
  2204.       PhysicalDeviceInfo->Channel,
  2205.       PhysicalDeviceInfo->TargetID);
  2206.       Controller->V2.PhysicalDeviceInformation[DeviceIndex] = NULL;
  2207.       Controller->V2.InquiryUnitSerialNumber[DeviceIndex] = NULL;
  2208.       kfree(PhysicalDeviceInfo);
  2209.       kfree(InquiryUnitSerialNumber);
  2210.     }
  2211.   Controller->V2.NeedPhysicalDeviceInformation = false;
  2212. }
  2213.       else if (CommandOpcode == DAC960_V2_GetLogicalDeviceInfoValid &&
  2214.        CommandStatus == DAC960_V2_NormalCompletion)
  2215. {
  2216.   DAC960_V2_LogicalDeviceInfo_T *NewLogicalDeviceInfo =
  2217.     &Controller->V2.NewLogicalDeviceInformation;
  2218.   unsigned short LogicalDeviceNumber =
  2219.     NewLogicalDeviceInfo->LogicalDeviceNumber;
  2220.   DAC960_V2_LogicalDeviceInfo_T *LogicalDeviceInfo =
  2221.     Controller->V2.LogicalDeviceInformation[LogicalDeviceNumber];
  2222.   if (LogicalDeviceInfo == NULL)
  2223.     {
  2224.       DAC960_V2_PhysicalDevice_T PhysicalDevice;
  2225.       PhysicalDevice.Controller = 0;
  2226.       PhysicalDevice.Channel = NewLogicalDeviceInfo->Channel;
  2227.       PhysicalDevice.TargetID = NewLogicalDeviceInfo->TargetID;
  2228.       PhysicalDevice.LogicalUnit = NewLogicalDeviceInfo->LogicalUnit;
  2229.       Controller->V2.LogicalDriveToVirtualDevice[LogicalDeviceNumber] =
  2230. PhysicalDevice;
  2231.       LogicalDeviceInfo = (DAC960_V2_LogicalDeviceInfo_T *)
  2232. kmalloc(sizeof(DAC960_V2_LogicalDeviceInfo_T), GFP_ATOMIC);
  2233.       Controller->V2.LogicalDeviceInformation[LogicalDeviceNumber] =
  2234. LogicalDeviceInfo;
  2235.       DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
  2236.       "Now Exists%sn", Controller,
  2237.       LogicalDeviceNumber,
  2238.       Controller->ControllerNumber,
  2239.       LogicalDeviceNumber,
  2240.       (LogicalDeviceInfo != NULL
  2241.        ? "" : " - Allocation Failed"));
  2242.       if (LogicalDeviceInfo != NULL)
  2243. {
  2244.   memset(LogicalDeviceInfo, 0,
  2245.  sizeof(DAC960_V2_LogicalDeviceInfo_T));
  2246.   DAC960_ComputeGenericDiskInfo(&Controller->GenericDiskInfo);
  2247. }
  2248.     }
  2249.   if (LogicalDeviceInfo != NULL)
  2250.     {
  2251.       unsigned long LogicalDeviceSize =
  2252. NewLogicalDeviceInfo->ConfigurableDeviceSize;
  2253.       if (NewLogicalDeviceInfo->LogicalDeviceState !=
  2254.   LogicalDeviceInfo->LogicalDeviceState)
  2255. DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
  2256. "is now %sn", Controller,
  2257. LogicalDeviceNumber,
  2258. Controller->ControllerNumber,
  2259. LogicalDeviceNumber,
  2260. (NewLogicalDeviceInfo->LogicalDeviceState
  2261.  == DAC960_V2_LogicalDevice_Online
  2262.  ? "ONLINE"
  2263.  : NewLogicalDeviceInfo->LogicalDeviceState
  2264.    == DAC960_V2_LogicalDevice_Critical
  2265.    ? "CRITICAL" : "OFFLINE"));
  2266.       if ((NewLogicalDeviceInfo->SoftErrors !=
  2267.    LogicalDeviceInfo->SoftErrors) ||
  2268.   (NewLogicalDeviceInfo->CommandsFailed !=
  2269.    LogicalDeviceInfo->CommandsFailed) ||
  2270.   (NewLogicalDeviceInfo->DeferredWriteErrors !=
  2271.    LogicalDeviceInfo->DeferredWriteErrors))
  2272. DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) Errors: "
  2273. "Soft = %d, Failed = %d, Deferred Write = %dn",
  2274. Controller, LogicalDeviceNumber,
  2275. Controller->ControllerNumber,
  2276. LogicalDeviceNumber,
  2277. NewLogicalDeviceInfo->SoftErrors,
  2278. NewLogicalDeviceInfo->CommandsFailed,
  2279. NewLogicalDeviceInfo->DeferredWriteErrors);
  2280.       if (NewLogicalDeviceInfo->ConsistencyCheckInProgress)
  2281. DAC960_V2_ReportProgress(Controller,
  2282.  "Consistency Check",
  2283.  LogicalDeviceNumber,
  2284.  NewLogicalDeviceInfo
  2285.  ->ConsistencyCheckBlockNumber,
  2286.  LogicalDeviceSize);
  2287.       else if (NewLogicalDeviceInfo->RebuildInProgress)
  2288. DAC960_V2_ReportProgress(Controller,
  2289.  "Rebuild",
  2290.  LogicalDeviceNumber,
  2291.  NewLogicalDeviceInfo
  2292.  ->RebuildBlockNumber,
  2293.  LogicalDeviceSize);
  2294.       else if (NewLogicalDeviceInfo->BackgroundInitializationInProgress)
  2295. DAC960_V2_ReportProgress(Controller,
  2296.  "Background Initialization",
  2297.  LogicalDeviceNumber,
  2298.  NewLogicalDeviceInfo
  2299.  ->BackgroundInitializationBlockNumber,
  2300.  LogicalDeviceSize);
  2301.       else if (NewLogicalDeviceInfo->ForegroundInitializationInProgress)
  2302. DAC960_V2_ReportProgress(Controller,
  2303.  "Foreground Initialization",
  2304.  LogicalDeviceNumber,
  2305.  NewLogicalDeviceInfo
  2306.  ->ForegroundInitializationBlockNumber,
  2307.  LogicalDeviceSize);
  2308.       else if (NewLogicalDeviceInfo->DataMigrationInProgress)
  2309. DAC960_V2_ReportProgress(Controller,
  2310.  "Data Migration",
  2311.  LogicalDeviceNumber,
  2312.  NewLogicalDeviceInfo
  2313.  ->DataMigrationBlockNumber,
  2314.  LogicalDeviceSize);
  2315.       else if (NewLogicalDeviceInfo->PatrolOperationInProgress)
  2316. DAC960_V2_ReportProgress(Controller,
  2317.  "Patrol Operation",
  2318.  LogicalDeviceNumber,
  2319.  NewLogicalDeviceInfo
  2320.  ->PatrolOperationBlockNumber,
  2321.  LogicalDeviceSize);
  2322.       if (LogicalDeviceInfo->BackgroundInitializationInProgress &&
  2323.   !NewLogicalDeviceInfo->BackgroundInitializationInProgress)
  2324. DAC960_Progress("Logical Drive %d (/dev/rd/c%dd%d) "
  2325. "Background Initialization %sn",
  2326. Controller,
  2327. LogicalDeviceNumber,
  2328. Controller->ControllerNumber,
  2329. LogicalDeviceNumber,
  2330. (NewLogicalDeviceInfo->LogicalDeviceControl
  2331.       .LogicalDeviceInitialized
  2332.  ? "Completed" : "Failed"));
  2333.       memcpy(LogicalDeviceInfo, NewLogicalDeviceInfo,
  2334.      sizeof(DAC960_V2_LogicalDeviceInfo_T));
  2335.     }
  2336.   Controller->V2.LogicalDriveFoundDuringScan
  2337.  [LogicalDeviceNumber] = true;
  2338.   NewLogicalDeviceInfo->LogicalDeviceNumber++;
  2339. }