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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 驱动编程 > 查看源码
DAC960.c
资源名称：block.rar　[点击查看]
上传用户：ajay2009
上传日期：2009-05-22
资源大小：495k
文件大小：260k
源码类别：

驱动编程

开发平台：

Unix_Linux

DAC960.c：源码内容
  1.   PhysicalDeviceInfo->PhysicalDeviceState =
  2.     DAC960_V2_Device_InvalidState;
  3.   memset(InquiryUnitSerialNumber, 0,
  4.  sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
  5.   InquiryUnitSerialNumber->PeripheralDeviceType = 0x1F;
  6.   for (DeviceIndex = DAC960_V2_MaxPhysicalDevices - 1;
  7.        DeviceIndex > PhysicalDeviceIndex;
  8.        DeviceIndex--)
  9.     {
  10.       Controller->V2.PhysicalDeviceInformation[DeviceIndex] =
  11. Controller->V2.PhysicalDeviceInformation[DeviceIndex-1];
  12.       Controller->V2.InquiryUnitSerialNumber[DeviceIndex] =
  13. Controller->V2.InquiryUnitSerialNumber[DeviceIndex-1];
  14.     }
  15.   Controller->V2.PhysicalDeviceInformation
  16.  [PhysicalDeviceIndex] =
  17.     PhysicalDeviceInfo;
  18.   Controller->V2.InquiryUnitSerialNumber
  19.  [PhysicalDeviceIndex] =
  20.     InquiryUnitSerialNumber;
  21.   Controller->V2.NeedDeviceSerialNumberInformation = true;
  22. }
  23.     }
  24.   if (PhysicalDeviceInfo != NULL)
  25.     {
  26.       if (NewPhysicalDeviceInfo->PhysicalDeviceState !=
  27.   PhysicalDeviceInfo->PhysicalDeviceState)
  28. DAC960_Critical(
  29.   "Physical Device %d:%d is now %sn", Controller,
  30.   NewPhysicalDeviceInfo->Channel,
  31.   NewPhysicalDeviceInfo->TargetID,
  32.   (NewPhysicalDeviceInfo->PhysicalDeviceState
  33.    == DAC960_V2_Device_Online
  34.    ? "ONLINE"
  35.    : NewPhysicalDeviceInfo->PhysicalDeviceState
  36.      == DAC960_V2_Device_Rebuild
  37.      ? "REBUILD"
  38.      : NewPhysicalDeviceInfo->PhysicalDeviceState
  39.        == DAC960_V2_Device_Missing
  40.        ? "MISSING"
  41.        : NewPhysicalDeviceInfo->PhysicalDeviceState
  42.  == DAC960_V2_Device_Critical
  43.  ? "CRITICAL"
  44.  : NewPhysicalDeviceInfo->PhysicalDeviceState
  45.    == DAC960_V2_Device_Dead
  46.    ? "DEAD"
  47.    : NewPhysicalDeviceInfo->PhysicalDeviceState
  48.      == DAC960_V2_Device_SuspectedDead
  49.      ? "SUSPECTED-DEAD"
  50.      : NewPhysicalDeviceInfo->PhysicalDeviceState
  51.        == DAC960_V2_Device_CommandedOffline
  52.        ? "COMMANDED-OFFLINE"
  53.        : NewPhysicalDeviceInfo->PhysicalDeviceState
  54.  == DAC960_V2_Device_Standby
  55.  ? "STANDBY" : "UNKNOWN"));
  56.       if ((NewPhysicalDeviceInfo->ParityErrors !=
  57.    PhysicalDeviceInfo->ParityErrors) ||
  58.   (NewPhysicalDeviceInfo->SoftErrors !=
  59.    PhysicalDeviceInfo->SoftErrors) ||
  60.   (NewPhysicalDeviceInfo->HardErrors !=
  61.    PhysicalDeviceInfo->HardErrors) ||
  62.   (NewPhysicalDeviceInfo->MiscellaneousErrors !=
  63.    PhysicalDeviceInfo->MiscellaneousErrors) ||
  64.   (NewPhysicalDeviceInfo->CommandTimeouts !=
  65.    PhysicalDeviceInfo->CommandTimeouts) ||
  66.   (NewPhysicalDeviceInfo->Retries !=
  67.    PhysicalDeviceInfo->Retries) ||
  68.   (NewPhysicalDeviceInfo->Aborts !=
  69.    PhysicalDeviceInfo->Aborts) ||
  70.   (NewPhysicalDeviceInfo->PredictedFailuresDetected !=
  71.    PhysicalDeviceInfo->PredictedFailuresDetected))
  72. {
  73.   DAC960_Critical("Physical Device %d:%d Errors: "
  74.   "Parity = %d, Soft = %d, "
  75.   "Hard = %d, Misc = %dn",
  76.   Controller,
  77.   NewPhysicalDeviceInfo->Channel,
  78.   NewPhysicalDeviceInfo->TargetID,
  79.   NewPhysicalDeviceInfo->ParityErrors,
  80.   NewPhysicalDeviceInfo->SoftErrors,
  81.   NewPhysicalDeviceInfo->HardErrors,
  82.   NewPhysicalDeviceInfo->MiscellaneousErrors);
  83.   DAC960_Critical("Physical Device %d:%d Errors: "
  84.   "Timeouts = %d, Retries = %d, "
  85.   "Aborts = %d, Predicted = %dn",
  86.   Controller,
  87.   NewPhysicalDeviceInfo->Channel,
  88.   NewPhysicalDeviceInfo->TargetID,
  89.   NewPhysicalDeviceInfo->CommandTimeouts,
  90.   NewPhysicalDeviceInfo->Retries,
  91.   NewPhysicalDeviceInfo->Aborts,
  92.   NewPhysicalDeviceInfo
  93.   ->PredictedFailuresDetected);
  94. }
  95.       if ((PhysicalDeviceInfo->PhysicalDeviceState
  96.    == DAC960_V2_Device_Dead ||
  97.    PhysicalDeviceInfo->PhysicalDeviceState
  98.    == DAC960_V2_Device_InvalidState) &&
  99.   NewPhysicalDeviceInfo->PhysicalDeviceState
  100.   != DAC960_V2_Device_Dead)
  101. Controller->V2.NeedDeviceSerialNumberInformation = true;
  102.       memcpy(PhysicalDeviceInfo, NewPhysicalDeviceInfo,
  103.      sizeof(DAC960_V2_PhysicalDeviceInfo_T));
  104.     }
  105.   NewPhysicalDeviceInfo->LogicalUnit++;
  106.   Controller->V2.PhysicalDeviceIndex++;
  107. }
  108.       else if (CommandOpcode == DAC960_V2_GetPhysicalDeviceInfoValid)
  109. {
  110.   unsigned int DeviceIndex;
  111.   for (DeviceIndex = Controller->V2.PhysicalDeviceIndex;
  112.        DeviceIndex < DAC960_V2_MaxPhysicalDevices;
  113.        DeviceIndex++)
  114.     {
  115.       DAC960_V2_PhysicalDeviceInfo_T *PhysicalDeviceInfo =
  116. Controller->V2.PhysicalDeviceInformation[DeviceIndex];
  117.       DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
  118. Controller->V2.InquiryUnitSerialNumber[DeviceIndex];
  119.       if (PhysicalDeviceInfo == NULL) break;
  120.       DAC960_Critical("Physical Device %d:%d No Longer Existsn",
  121.       Controller,
  122.       PhysicalDeviceInfo->Channel,
  123.       PhysicalDeviceInfo->TargetID);
  124.       Controller->V2.PhysicalDeviceInformation[DeviceIndex] = NULL;
  125.       Controller->V2.InquiryUnitSerialNumber[DeviceIndex] = NULL;
  126.       kfree(PhysicalDeviceInfo);
  127.       kfree(InquiryUnitSerialNumber);
  128.     }
  129.   Controller->V2.NeedPhysicalDeviceInformation = false;
  130. }
  131.       else if (CommandOpcode == DAC960_V2_GetLogicalDeviceInfoValid &&
  132.        CommandStatus == DAC960_V2_NormalCompletion)
  133. {
  134.   DAC960_V2_LogicalDeviceInfo_T *NewLogicalDeviceInfo =
  135.     Controller->V2.NewLogicalDeviceInformation;
  136.   unsigned short LogicalDeviceNumber =
  137.     NewLogicalDeviceInfo->LogicalDeviceNumber;
  138.   DAC960_V2_LogicalDeviceInfo_T *LogicalDeviceInfo =
  139.     Controller->V2.LogicalDeviceInformation[LogicalDeviceNumber];
  140.   if (LogicalDeviceInfo == NULL)
  141.     {
  142.       DAC960_V2_PhysicalDevice_T PhysicalDevice;
  143.       PhysicalDevice.Controller = 0;
  144.       PhysicalDevice.Channel = NewLogicalDeviceInfo->Channel;
  145.       PhysicalDevice.TargetID = NewLogicalDeviceInfo->TargetID;
  146.       PhysicalDevice.LogicalUnit = NewLogicalDeviceInfo->LogicalUnit;
  147.       Controller->V2.LogicalDriveToVirtualDevice[LogicalDeviceNumber] =
  148. PhysicalDevice;
  149.       LogicalDeviceInfo = (DAC960_V2_LogicalDeviceInfo_T *)
  150. kmalloc(sizeof(DAC960_V2_LogicalDeviceInfo_T), GFP_ATOMIC);
  151.       Controller->V2.LogicalDeviceInformation[LogicalDeviceNumber] =
  152. LogicalDeviceInfo;
  153.       DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
  154.       "Now Exists%sn", Controller,
  155.       LogicalDeviceNumber,
  156.       Controller->ControllerNumber,
  157.       LogicalDeviceNumber,
  158.       (LogicalDeviceInfo != NULL
  159.        ? "" : " - Allocation Failed"));
  160.       if (LogicalDeviceInfo != NULL)
  161. {
  162.   memset(LogicalDeviceInfo, 0,
  163.  sizeof(DAC960_V2_LogicalDeviceInfo_T));
  164.   DAC960_ComputeGenericDiskInfo(Controller);
  165. }
  166.     }
  167.   if (LogicalDeviceInfo != NULL)
  168.     {
  169.       unsigned long LogicalDeviceSize =
  170. NewLogicalDeviceInfo->ConfigurableDeviceSize;
  171.       if (NewLogicalDeviceInfo->LogicalDeviceState !=
  172.   LogicalDeviceInfo->LogicalDeviceState)
  173. DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
  174. "is now %sn", Controller,
  175. LogicalDeviceNumber,
  176. Controller->ControllerNumber,
  177. LogicalDeviceNumber,
  178. (NewLogicalDeviceInfo->LogicalDeviceState
  179.  == DAC960_V2_LogicalDevice_Online
  180.  ? "ONLINE"
  181.  : NewLogicalDeviceInfo->LogicalDeviceState
  182.    == DAC960_V2_LogicalDevice_Critical
  183.    ? "CRITICAL" : "OFFLINE"));
  184.       if ((NewLogicalDeviceInfo->SoftErrors !=
  185.    LogicalDeviceInfo->SoftErrors) ||
  186.   (NewLogicalDeviceInfo->CommandsFailed !=
  187.    LogicalDeviceInfo->CommandsFailed) ||
  188.   (NewLogicalDeviceInfo->DeferredWriteErrors !=
  189.    LogicalDeviceInfo->DeferredWriteErrors))
  190. DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) Errors: "
  191. "Soft = %d, Failed = %d, Deferred Write = %dn",
  192. Controller, LogicalDeviceNumber,
  193. Controller->ControllerNumber,
  194. LogicalDeviceNumber,
  195. NewLogicalDeviceInfo->SoftErrors,
  196. NewLogicalDeviceInfo->CommandsFailed,
  197. NewLogicalDeviceInfo->DeferredWriteErrors);
  198.       if (NewLogicalDeviceInfo->ConsistencyCheckInProgress)
  199. DAC960_V2_ReportProgress(Controller,
  200.  "Consistency Check",
  201.  LogicalDeviceNumber,
  202.  NewLogicalDeviceInfo
  203.  ->ConsistencyCheckBlockNumber,
  204.  LogicalDeviceSize);
  205.       else if (NewLogicalDeviceInfo->RebuildInProgress)
  206. DAC960_V2_ReportProgress(Controller,
  207.  "Rebuild",
  208.  LogicalDeviceNumber,
  209.  NewLogicalDeviceInfo
  210.  ->RebuildBlockNumber,
  211.  LogicalDeviceSize);
  212.       else if (NewLogicalDeviceInfo->BackgroundInitializationInProgress)
  213. DAC960_V2_ReportProgress(Controller,
  214.  "Background Initialization",
  215.  LogicalDeviceNumber,
  216.  NewLogicalDeviceInfo
  217.  ->BackgroundInitializationBlockNumber,
  218.  LogicalDeviceSize);
  219.       else if (NewLogicalDeviceInfo->ForegroundInitializationInProgress)
  220. DAC960_V2_ReportProgress(Controller,
  221.  "Foreground Initialization",
  222.  LogicalDeviceNumber,
  223.  NewLogicalDeviceInfo
  224.  ->ForegroundInitializationBlockNumber,
  225.  LogicalDeviceSize);
  226.       else if (NewLogicalDeviceInfo->DataMigrationInProgress)
  227. DAC960_V2_ReportProgress(Controller,
  228.  "Data Migration",
  229.  LogicalDeviceNumber,
  230.  NewLogicalDeviceInfo
  231.  ->DataMigrationBlockNumber,
  232.  LogicalDeviceSize);
  233.       else if (NewLogicalDeviceInfo->PatrolOperationInProgress)
  234. DAC960_V2_ReportProgress(Controller,
  235.  "Patrol Operation",
  236.  LogicalDeviceNumber,
  237.  NewLogicalDeviceInfo
  238.  ->PatrolOperationBlockNumber,
  239.  LogicalDeviceSize);
  240.       if (LogicalDeviceInfo->BackgroundInitializationInProgress &&
  241.   !NewLogicalDeviceInfo->BackgroundInitializationInProgress)
  242. DAC960_Progress("Logical Drive %d (/dev/rd/c%dd%d) "
  243. "Background Initialization %sn",
  244. Controller,
  245. LogicalDeviceNumber,
  246. Controller->ControllerNumber,
  247. LogicalDeviceNumber,
  248. (NewLogicalDeviceInfo->LogicalDeviceControl
  249.       .LogicalDeviceInitialized
  250.  ? "Completed" : "Failed"));
  251.       memcpy(LogicalDeviceInfo, NewLogicalDeviceInfo,
  252.      sizeof(DAC960_V2_LogicalDeviceInfo_T));
  253.     }
  254.   Controller->V2.LogicalDriveFoundDuringScan
  255.  [LogicalDeviceNumber] = true;
  256.   NewLogicalDeviceInfo->LogicalDeviceNumber++;
  257. }
  258.       else if (CommandOpcode == DAC960_V2_GetLogicalDeviceInfoValid)
  259. {
  260.   int LogicalDriveNumber;
  261.   for (LogicalDriveNumber = 0;
  262.        LogicalDriveNumber < DAC960_MaxLogicalDrives;
  263.        LogicalDriveNumber++)
  264.     {
  265.       DAC960_V2_LogicalDeviceInfo_T *LogicalDeviceInfo =
  266. Controller->V2.LogicalDeviceInformation[LogicalDriveNumber];
  267.       if (LogicalDeviceInfo == NULL ||
  268.   Controller->V2.LogicalDriveFoundDuringScan
  269.  [LogicalDriveNumber])
  270. continue;
  271.       DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
  272.       "No Longer Existsn", Controller,
  273.       LogicalDriveNumber,
  274.       Controller->ControllerNumber,
  275.       LogicalDriveNumber);
  276.       Controller->V2.LogicalDeviceInformation
  277.      [LogicalDriveNumber] = NULL;
  278.       kfree(LogicalDeviceInfo);
  279.       Controller->LogicalDriveInitiallyAccessible
  280.   [LogicalDriveNumber] = false;
  281.       DAC960_ComputeGenericDiskInfo(Controller);
  282.     }
  283.   Controller->V2.NeedLogicalDeviceInformation = false;
  284. }
  285.       else if (CommandOpcode == DAC960_V2_SCSI_10_Passthru)
  286.         {
  287.     DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
  288. Controller->V2.InquiryUnitSerialNumber[Controller->V2.PhysicalDeviceIndex - 1];
  290.     if (CommandStatus != DAC960_V2_NormalCompletion) {
  291. memset(InquiryUnitSerialNumber,
  292. 0, sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
  293. InquiryUnitSerialNumber->PeripheralDeviceType = 0x1F;
  294.     } else
  295.    memcpy(InquiryUnitSerialNumber,
  296. Controller->V2.NewInquiryUnitSerialNumber,
  297. sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
  299.      Controller->V2.NeedDeviceSerialNumberInformation = false;
  300.         }
  302.       if (Controller->V2.HealthStatusBuffer->NextEventSequenceNumber
  303.   - Controller->V2.NextEventSequenceNumber > 0)
  304. {
  305.   CommandMailbox->GetEvent.CommandOpcode = DAC960_V2_IOCTL;
  306.   CommandMailbox->GetEvent.DataTransferSize = sizeof(DAC960_V2_Event_T);
  307.   CommandMailbox->GetEvent.EventSequenceNumberHigh16 =
  308.     Controller->V2.NextEventSequenceNumber >> 16;
  309.   CommandMailbox->GetEvent.ControllerNumber = 0;
  310.   CommandMailbox->GetEvent.IOCTL_Opcode =
  311.     DAC960_V2_GetEvent;
  312.   CommandMailbox->GetEvent.EventSequenceNumberLow16 =
  313.     Controller->V2.NextEventSequenceNumber & 0xFFFF;
  314.   CommandMailbox->GetEvent.DataTransferMemoryAddress
  315.   .ScatterGatherSegments[0]
  316.   .SegmentDataPointer =
  317.     Controller->V2.EventDMA;
  318.   CommandMailbox->GetEvent.DataTransferMemoryAddress
  319.   .ScatterGatherSegments[0]
  320.   .SegmentByteCount =
  321.     CommandMailbox->GetEvent.DataTransferSize;
  322.   DAC960_QueueCommand(Command);
  323.   return;
  324. }
  325.       if (Controller->V2.NeedPhysicalDeviceInformation)
  326. {
  327.   if (Controller->V2.NeedDeviceSerialNumberInformation)
  328.     {
  329.       DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
  330.                 Controller->V2.NewInquiryUnitSerialNumber;
  331.       InquiryUnitSerialNumber->PeripheralDeviceType = 0x1F;
  333.       DAC960_V2_ConstructNewUnitSerialNumber(Controller, CommandMailbox,
  334. Controller->V2.NewPhysicalDeviceInformation->Channel,
  335. Controller->V2.NewPhysicalDeviceInformation->TargetID,
  336. Controller->V2.NewPhysicalDeviceInformation->LogicalUnit - 1);
  339.       DAC960_QueueCommand(Command);
  340.       return;
  341.     }
  342.   if (Controller->V2.StartPhysicalDeviceInformationScan)
  343.     {
  344.       Controller->V2.PhysicalDeviceIndex = 0;
  345.       Controller->V2.NewPhysicalDeviceInformation->Channel = 0;
  346.       Controller->V2.NewPhysicalDeviceInformation->TargetID = 0;
  347.       Controller->V2.NewPhysicalDeviceInformation->LogicalUnit = 0;
  348.       Controller->V2.StartPhysicalDeviceInformationScan = false;
  349.     }
  350.   CommandMailbox->PhysicalDeviceInfo.CommandOpcode = DAC960_V2_IOCTL;
  351.   CommandMailbox->PhysicalDeviceInfo.DataTransferSize =
  352.     sizeof(DAC960_V2_PhysicalDeviceInfo_T);
  353.   CommandMailbox->PhysicalDeviceInfo.PhysicalDevice.LogicalUnit =
  354.     Controller->V2.NewPhysicalDeviceInformation->LogicalUnit;
  355.   CommandMailbox->PhysicalDeviceInfo.PhysicalDevice.TargetID =
  356.     Controller->V2.NewPhysicalDeviceInformation->TargetID;
  357.   CommandMailbox->PhysicalDeviceInfo.PhysicalDevice.Channel =
  358.     Controller->V2.NewPhysicalDeviceInformation->Channel;
  359.   CommandMailbox->PhysicalDeviceInfo.IOCTL_Opcode =
  360.     DAC960_V2_GetPhysicalDeviceInfoValid;
  361.   CommandMailbox->PhysicalDeviceInfo.DataTransferMemoryAddress
  362.     .ScatterGatherSegments[0]
  363.     .SegmentDataPointer =
  364.     Controller->V2.NewPhysicalDeviceInformationDMA;
  365.   CommandMailbox->PhysicalDeviceInfo.DataTransferMemoryAddress
  366.     .ScatterGatherSegments[0]
  367.     .SegmentByteCount =
  368.     CommandMailbox->PhysicalDeviceInfo.DataTransferSize;
  369.   DAC960_QueueCommand(Command);
  370.   return;
  371. }
  372.       if (Controller->V2.NeedLogicalDeviceInformation)
  373. {
  374.   if (Controller->V2.StartLogicalDeviceInformationScan)
  375.     {
  376.       int LogicalDriveNumber;
  377.       for (LogicalDriveNumber = 0;
  378.    LogicalDriveNumber < DAC960_MaxLogicalDrives;
  379.    LogicalDriveNumber++)
  380. Controller->V2.LogicalDriveFoundDuringScan
  381.        [LogicalDriveNumber] = false;
  382.       Controller->V2.NewLogicalDeviceInformation->LogicalDeviceNumber = 0;
  383.       Controller->V2.StartLogicalDeviceInformationScan = false;
  384.     }
  385.   CommandMailbox->LogicalDeviceInfo.CommandOpcode = DAC960_V2_IOCTL;
  386.   CommandMailbox->LogicalDeviceInfo.DataTransferSize =
  387.     sizeof(DAC960_V2_LogicalDeviceInfo_T);
  388.   CommandMailbox->LogicalDeviceInfo.LogicalDevice.LogicalDeviceNumber =
  389.     Controller->V2.NewLogicalDeviceInformation->LogicalDeviceNumber;
  390.   CommandMailbox->LogicalDeviceInfo.IOCTL_Opcode =
  391.     DAC960_V2_GetLogicalDeviceInfoValid;
  392.   CommandMailbox->LogicalDeviceInfo.DataTransferMemoryAddress
  393.    .ScatterGatherSegments[0]
  394.    .SegmentDataPointer =
  395.     Controller->V2.NewLogicalDeviceInformationDMA;
  396.   CommandMailbox->LogicalDeviceInfo.DataTransferMemoryAddress
  397.    .ScatterGatherSegments[0]
  398.    .SegmentByteCount =
  399.     CommandMailbox->LogicalDeviceInfo.DataTransferSize;
  400.   DAC960_QueueCommand(Command);
  401.   return;
  402. }
  403.       Controller->MonitoringTimerCount++;
  404.       Controller->MonitoringTimer.expires =
  405. jiffies + DAC960_HealthStatusMonitoringInterval;
  406.        add_timer(&Controller->MonitoringTimer);
  407.     }
  408.   if (CommandType == DAC960_ImmediateCommand)
  409.     {
  410.       complete(Command->Completion);
  411.       Command->Completion = NULL;
  412.       return;
  413.     }
  414.   if (CommandType == DAC960_QueuedCommand)
  415.     {
  416.       DAC960_V2_KernelCommand_T *KernelCommand = Command->V2.KernelCommand;
  417.       KernelCommand->CommandStatus = CommandStatus;
  418.       KernelCommand->RequestSenseLength = Command->V2.RequestSenseLength;
  419.       KernelCommand->DataTransferLength = Command->V2.DataTransferResidue;
  420.       Command->V2.KernelCommand = NULL;
  421.       DAC960_DeallocateCommand(Command);
  422.       KernelCommand->CompletionFunction(KernelCommand);
  423.       return;
  424.     }
  425.   /*
  426.     Queue a Status Monitoring Command to the Controller using the just
  427.     completed Command if one was deferred previously due to lack of a
  428.     free Command when the Monitoring Timer Function was called.
  429.   */
  430.   if (Controller->MonitoringCommandDeferred)
  431.     {
  432.       Controller->MonitoringCommandDeferred = false;
  433.       DAC960_V2_QueueMonitoringCommand(Command);
  434.       return;
  435.     }
  436.   /*
  437.     Deallocate the Command.
  438.   */
  439.   DAC960_DeallocateCommand(Command);
  440.   /*
  441.     Wake up any processes waiting on a free Command.
  442.   */
  443.   wake_up(&Controller->CommandWaitQueue);
  444. }
  446. /*
  447.   DAC960_GEM_InterruptHandler handles hardware interrupts from DAC960 GEM Series
  448.   Controllers.
  449. */
  451. static irqreturn_t DAC960_GEM_InterruptHandler(int IRQ_Channel,
  452.        void *DeviceIdentifier,
  453.        struct pt_regs *InterruptRegisters)
  454. {
  455.   DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
  456.   void __iomem *ControllerBaseAddress = Controller->BaseAddress;
  457.   DAC960_V2_StatusMailbox_T *NextStatusMailbox;
  458.   unsigned long flags;
  460.   spin_lock_irqsave(&Controller->queue_lock, flags);
  461.   DAC960_GEM_AcknowledgeInterrupt(ControllerBaseAddress);
  462.   NextStatusMailbox = Controller->V2.NextStatusMailbox;
  463.   while (NextStatusMailbox->Fields.CommandIdentifier > 0)
  464.     {
  465.        DAC960_V2_CommandIdentifier_T CommandIdentifier =
  466.            NextStatusMailbox->Fields.CommandIdentifier;
  467.        DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
  468.        Command->V2.CommandStatus = NextStatusMailbox->Fields.CommandStatus;
  469.        Command->V2.RequestSenseLength =
  470.            NextStatusMailbox->Fields.RequestSenseLength;
  471.        Command->V2.DataTransferResidue =
  472.            NextStatusMailbox->Fields.DataTransferResidue;
  473.        NextStatusMailbox->Words[0] = 0;
  474.        if (++NextStatusMailbox > Controller->V2.LastStatusMailbox)
  475.            NextStatusMailbox = Controller->V2.FirstStatusMailbox;
  476.        DAC960_V2_ProcessCompletedCommand(Command);
  477.     }
  478.   Controller->V2.NextStatusMailbox = NextStatusMailbox;
  479.   /*
  480.     Attempt to remove additional I/O Requests from the Controller's
  481.     I/O Request Queue and queue them to the Controller.
  482.   */
  483.   DAC960_ProcessRequest(Controller);
  484.   spin_unlock_irqrestore(&Controller->queue_lock, flags);
  485.   return IRQ_HANDLED;
  486. }
  488. /*
  489.   DAC960_BA_InterruptHandler handles hardware interrupts from DAC960 BA Series
  490.   Controllers.
  491. */
  493. static irqreturn_t DAC960_BA_InterruptHandler(int IRQ_Channel,
  494.        void *DeviceIdentifier,
  495.        struct pt_regs *InterruptRegisters)
  496. {
  497.   DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
  498.   void __iomem *ControllerBaseAddress = Controller->BaseAddress;
  499.   DAC960_V2_StatusMailbox_T *NextStatusMailbox;
  500.   unsigned long flags;
  502.   spin_lock_irqsave(&Controller->queue_lock, flags);
  503.   DAC960_BA_AcknowledgeInterrupt(ControllerBaseAddress);
  504.   NextStatusMailbox = Controller->V2.NextStatusMailbox;
  505.   while (NextStatusMailbox->Fields.CommandIdentifier > 0)
  506.     {
  507.       DAC960_V2_CommandIdentifier_T CommandIdentifier =
  508. NextStatusMailbox->Fields.CommandIdentifier;
  509.       DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
  510.       Command->V2.CommandStatus = NextStatusMailbox->Fields.CommandStatus;
  511.       Command->V2.RequestSenseLength =
  512. NextStatusMailbox->Fields.RequestSenseLength;
  513.       Command->V2.DataTransferResidue =
  514. NextStatusMailbox->Fields.DataTransferResidue;
  515.       NextStatusMailbox->Words[0] = 0;
  516.       if (++NextStatusMailbox > Controller->V2.LastStatusMailbox)
  517. NextStatusMailbox = Controller->V2.FirstStatusMailbox;
  518.       DAC960_V2_ProcessCompletedCommand(Command);
  519.     }
  520.   Controller->V2.NextStatusMailbox = NextStatusMailbox;
  521.   /*
  522.     Attempt to remove additional I/O Requests from the Controller's
  523.     I/O Request Queue and queue them to the Controller.
  524.   */
  525.   DAC960_ProcessRequest(Controller);
  526.   spin_unlock_irqrestore(&Controller->queue_lock, flags);
  527.   return IRQ_HANDLED;
  528. }
  531. /*
  532.   DAC960_LP_InterruptHandler handles hardware interrupts from DAC960 LP Series
  533.   Controllers.
  534. */
  536. static irqreturn_t DAC960_LP_InterruptHandler(int IRQ_Channel,
  537.        void *DeviceIdentifier,
  538.        struct pt_regs *InterruptRegisters)
  539. {
  540.   DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
  541.   void __iomem *ControllerBaseAddress = Controller->BaseAddress;
  542.   DAC960_V2_StatusMailbox_T *NextStatusMailbox;
  543.   unsigned long flags;
  545.   spin_lock_irqsave(&Controller->queue_lock, flags);
  546.   DAC960_LP_AcknowledgeInterrupt(ControllerBaseAddress);
  547.   NextStatusMailbox = Controller->V2.NextStatusMailbox;
  548.   while (NextStatusMailbox->Fields.CommandIdentifier > 0)
  549.     {
  550.       DAC960_V2_CommandIdentifier_T CommandIdentifier =
  551. NextStatusMailbox->Fields.CommandIdentifier;
  552.       DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
  553.       Command->V2.CommandStatus = NextStatusMailbox->Fields.CommandStatus;
  554.       Command->V2.RequestSenseLength =
  555. NextStatusMailbox->Fields.RequestSenseLength;
  556.       Command->V2.DataTransferResidue =
  557. NextStatusMailbox->Fields.DataTransferResidue;
  558.       NextStatusMailbox->Words[0] = 0;
  559.       if (++NextStatusMailbox > Controller->V2.LastStatusMailbox)
  560. NextStatusMailbox = Controller->V2.FirstStatusMailbox;
  561.       DAC960_V2_ProcessCompletedCommand(Command);
  562.     }
  563.   Controller->V2.NextStatusMailbox = NextStatusMailbox;
  564.   /*
  565.     Attempt to remove additional I/O Requests from the Controller's
  566.     I/O Request Queue and queue them to the Controller.
  567.   */
  568.   DAC960_ProcessRequest(Controller);
  569.   spin_unlock_irqrestore(&Controller->queue_lock, flags);
  570.   return IRQ_HANDLED;
  571. }
  574. /*
  575.   DAC960_LA_InterruptHandler handles hardware interrupts from DAC960 LA Series
  576.   Controllers.
  577. */
  579. static irqreturn_t DAC960_LA_InterruptHandler(int IRQ_Channel,
  580.        void *DeviceIdentifier,
  581.        struct pt_regs *InterruptRegisters)
  582. {
  583.   DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
  584.   void __iomem *ControllerBaseAddress = Controller->BaseAddress;
  585.   DAC960_V1_StatusMailbox_T *NextStatusMailbox;
  586.   unsigned long flags;
  588.   spin_lock_irqsave(&Controller->queue_lock, flags);
  589.   DAC960_LA_AcknowledgeInterrupt(ControllerBaseAddress);
  590.   NextStatusMailbox = Controller->V1.NextStatusMailbox;
  591.   while (NextStatusMailbox->Fields.Valid)
  592.     {
  593.       DAC960_V1_CommandIdentifier_T CommandIdentifier =
  594. NextStatusMailbox->Fields.CommandIdentifier;
  595.       DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
  596.       Command->V1.CommandStatus = NextStatusMailbox->Fields.CommandStatus;
  597.       NextStatusMailbox->Word = 0;
  598.       if (++NextStatusMailbox > Controller->V1.LastStatusMailbox)
  599. NextStatusMailbox = Controller->V1.FirstStatusMailbox;
  600.       DAC960_V1_ProcessCompletedCommand(Command);
  601.     }
  602.   Controller->V1.NextStatusMailbox = NextStatusMailbox;
  603.   /*
  604.     Attempt to remove additional I/O Requests from the Controller's
  605.     I/O Request Queue and queue them to the Controller.
  606.   */
  607.   DAC960_ProcessRequest(Controller);
  608.   spin_unlock_irqrestore(&Controller->queue_lock, flags);
  609.   return IRQ_HANDLED;
  610. }
  613. /*
  614.   DAC960_PG_InterruptHandler handles hardware interrupts from DAC960 PG Series
  615.   Controllers.
  616. */
  618. static irqreturn_t DAC960_PG_InterruptHandler(int IRQ_Channel,
  619.        void *DeviceIdentifier,
  620.        struct pt_regs *InterruptRegisters)
  621. {
  622.   DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
  623.   void __iomem *ControllerBaseAddress = Controller->BaseAddress;
  624.   DAC960_V1_StatusMailbox_T *NextStatusMailbox;
  625.   unsigned long flags;
  627.   spin_lock_irqsave(&Controller->queue_lock, flags);
  628.   DAC960_PG_AcknowledgeInterrupt(ControllerBaseAddress);
  629.   NextStatusMailbox = Controller->V1.NextStatusMailbox;
  630.   while (NextStatusMailbox->Fields.Valid)
  631.     {
  632.       DAC960_V1_CommandIdentifier_T CommandIdentifier =
  633. NextStatusMailbox->Fields.CommandIdentifier;
  634.       DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
  635.       Command->V1.CommandStatus = NextStatusMailbox->Fields.CommandStatus;
  636.       NextStatusMailbox->Word = 0;
  637.       if (++NextStatusMailbox > Controller->V1.LastStatusMailbox)
  638. NextStatusMailbox = Controller->V1.FirstStatusMailbox;
  639.       DAC960_V1_ProcessCompletedCommand(Command);
  640.     }
  641.   Controller->V1.NextStatusMailbox = NextStatusMailbox;
  642.   /*
  643.     Attempt to remove additional I/O Requests from the Controller's
  644.     I/O Request Queue and queue them to the Controller.
  645.   */
  646.   DAC960_ProcessRequest(Controller);
  647.   spin_unlock_irqrestore(&Controller->queue_lock, flags);
  648.   return IRQ_HANDLED;
  649. }
  652. /*
  653.   DAC960_PD_InterruptHandler handles hardware interrupts from DAC960 PD Series
  654.   Controllers.
  655. */
  657. static irqreturn_t DAC960_PD_InterruptHandler(int IRQ_Channel,
  658.        void *DeviceIdentifier,
  659.        struct pt_regs *InterruptRegisters)
  660. {
  661.   DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
  662.   void __iomem *ControllerBaseAddress = Controller->BaseAddress;
  663.   unsigned long flags;
  665.   spin_lock_irqsave(&Controller->queue_lock, flags);
  666.   while (DAC960_PD_StatusAvailableP(ControllerBaseAddress))
  667.     {
  668.       DAC960_V1_CommandIdentifier_T CommandIdentifier =
  669. DAC960_PD_ReadStatusCommandIdentifier(ControllerBaseAddress);
  670.       DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
  671.       Command->V1.CommandStatus =
  672. DAC960_PD_ReadStatusRegister(ControllerBaseAddress);
  673.       DAC960_PD_AcknowledgeInterrupt(ControllerBaseAddress);
  674.       DAC960_PD_AcknowledgeStatus(ControllerBaseAddress);
  675.       DAC960_V1_ProcessCompletedCommand(Command);
  676.     }
  677.   /*
  678.     Attempt to remove additional I/O Requests from the Controller's
  679.     I/O Request Queue and queue them to the Controller.
  680.   */
  681.   DAC960_ProcessRequest(Controller);
  682.   spin_unlock_irqrestore(&Controller->queue_lock, flags);
  683.   return IRQ_HANDLED;
  684. }
  687. /*
  688.   DAC960_P_InterruptHandler handles hardware interrupts from DAC960 P Series
  689.   Controllers.
  691.   Translations of DAC960_V1_Enquiry and DAC960_V1_GetDeviceState rely
  692.   on the data having been placed into DAC960_Controller_T, rather than
  693.   an arbitrary buffer.
  694. */
  696. static irqreturn_t DAC960_P_InterruptHandler(int IRQ_Channel,
  697.       void *DeviceIdentifier,
  698.       struct pt_regs *InterruptRegisters)
  699. {
  700.   DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
  701.   void __iomem *ControllerBaseAddress = Controller->BaseAddress;
  702.   unsigned long flags;
  704.   spin_lock_irqsave(&Controller->queue_lock, flags);
  705.   while (DAC960_PD_StatusAvailableP(ControllerBaseAddress))
  706.     {
  707.       DAC960_V1_CommandIdentifier_T CommandIdentifier =
  708. DAC960_PD_ReadStatusCommandIdentifier(ControllerBaseAddress);
  709.       DAC960_Command_T *Command = Controller->Commands[CommandIdentifier-1];
  710.       DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
  711.       DAC960_V1_CommandOpcode_T CommandOpcode =
  712. CommandMailbox->Common.CommandOpcode;
  713.       Command->V1.CommandStatus =
  714. DAC960_PD_ReadStatusRegister(ControllerBaseAddress);
  715.       DAC960_PD_AcknowledgeInterrupt(ControllerBaseAddress);
  716.       DAC960_PD_AcknowledgeStatus(ControllerBaseAddress);
  717.       switch (CommandOpcode)
  718. {
  719. case DAC960_V1_Enquiry_Old:
  720.   Command->V1.CommandMailbox.Common.CommandOpcode = DAC960_V1_Enquiry;
  721.   DAC960_P_To_PD_TranslateEnquiry(Controller->V1.NewEnquiry);
  722.   break;
  723. case DAC960_V1_GetDeviceState_Old:
  724.   Command->V1.CommandMailbox.Common.CommandOpcode =
  725.      DAC960_V1_GetDeviceState;
  726.   DAC960_P_To_PD_TranslateDeviceState(Controller->V1.NewDeviceState);
  727.   break;
  728. case DAC960_V1_Read_Old:
  729.   Command->V1.CommandMailbox.Common.CommandOpcode = DAC960_V1_Read;
  730.   DAC960_P_To_PD_TranslateReadWriteCommand(CommandMailbox);
  731.   break;
  732. case DAC960_V1_Write_Old:
  733.   Command->V1.CommandMailbox.Common.CommandOpcode = DAC960_V1_Write;
  734.   DAC960_P_To_PD_TranslateReadWriteCommand(CommandMailbox);
  735.   break;
  736. case DAC960_V1_ReadWithScatterGather_Old:
  737.   Command->V1.CommandMailbox.Common.CommandOpcode =
  738.     DAC960_V1_ReadWithScatterGather;
  739.   DAC960_P_To_PD_TranslateReadWriteCommand(CommandMailbox);
  740.   break;
  741. case DAC960_V1_WriteWithScatterGather_Old:
  742.   Command->V1.CommandMailbox.Common.CommandOpcode =
  743.     DAC960_V1_WriteWithScatterGather;
  744.   DAC960_P_To_PD_TranslateReadWriteCommand(CommandMailbox);
  745.   break;
  746. default:
  747.   break;
  748. }
  749.       DAC960_V1_ProcessCompletedCommand(Command);
  750.     }
  751.   /*
  752.     Attempt to remove additional I/O Requests from the Controller's
  753.     I/O Request Queue and queue them to the Controller.
  754.   */
  755.   DAC960_ProcessRequest(Controller);
  756.   spin_unlock_irqrestore(&Controller->queue_lock, flags);
  757.   return IRQ_HANDLED;
  758. }
  761. /*
  762.   DAC960_V1_QueueMonitoringCommand queues a Monitoring Command to DAC960 V1
  763.   Firmware Controllers.
  764. */
  766. static void DAC960_V1_QueueMonitoringCommand(DAC960_Command_T *Command)
  767. {
  768.   DAC960_Controller_T *Controller = Command->Controller;
  769.   DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
  770.   DAC960_V1_ClearCommand(Command);
  771.   Command->CommandType = DAC960_MonitoringCommand;
  772.   CommandMailbox->Type3.CommandOpcode = DAC960_V1_Enquiry;
  773.   CommandMailbox->Type3.BusAddress = Controller->V1.NewEnquiryDMA;
  774.   DAC960_QueueCommand(Command);
  775. }
  778. /*
  779.   DAC960_V2_QueueMonitoringCommand queues a Monitoring Command to DAC960 V2
  780.   Firmware Controllers.
  781. */
  783. static void DAC960_V2_QueueMonitoringCommand(DAC960_Command_T *Command)
  784. {
  785.   DAC960_Controller_T *Controller = Command->Controller;
  786.   DAC960_V2_CommandMailbox_T *CommandMailbox = &Command->V2.CommandMailbox;
  787.   DAC960_V2_ClearCommand(Command);
  788.   Command->CommandType = DAC960_MonitoringCommand;
  789.   CommandMailbox->ControllerInfo.CommandOpcode = DAC960_V2_IOCTL;
  790.   CommandMailbox->ControllerInfo.CommandControlBits
  791. .DataTransferControllerToHost = true;
  792.   CommandMailbox->ControllerInfo.CommandControlBits
  793. .NoAutoRequestSense = true;
  794.   CommandMailbox->ControllerInfo.DataTransferSize =
  795.     sizeof(DAC960_V2_ControllerInfo_T);
  796.   CommandMailbox->ControllerInfo.ControllerNumber = 0;
  797.   CommandMailbox->ControllerInfo.IOCTL_Opcode = DAC960_V2_GetControllerInfo;
  798.   CommandMailbox->ControllerInfo.DataTransferMemoryAddress
  799. .ScatterGatherSegments[0]
  800. .SegmentDataPointer =
  801.     Controller->V2.NewControllerInformationDMA;
  802.   CommandMailbox->ControllerInfo.DataTransferMemoryAddress
  803. .ScatterGatherSegments[0]
  804. .SegmentByteCount =
  805.     CommandMailbox->ControllerInfo.DataTransferSize;
  806.   DAC960_QueueCommand(Command);
  807. }
  810. /*
  811.   DAC960_MonitoringTimerFunction is the timer function for monitoring
  812.   the status of DAC960 Controllers.
  813. */
  815. static void DAC960_MonitoringTimerFunction(unsigned long TimerData)
  816. {
  817.   DAC960_Controller_T *Controller = (DAC960_Controller_T *) TimerData;
  818.   DAC960_Command_T *Command;
  819.   unsigned long flags;
  821.   if (Controller->FirmwareType == DAC960_V1_Controller)
  822.     {
  823.       spin_lock_irqsave(&Controller->queue_lock, flags);
  824.       /*
  825. Queue a Status Monitoring Command to Controller.
  826.       */
  827.       Command = DAC960_AllocateCommand(Controller);
  828.       if (Command != NULL)
  829. DAC960_V1_QueueMonitoringCommand(Command);
  830.       else Controller->MonitoringCommandDeferred = true;
  831.       spin_unlock_irqrestore(&Controller->queue_lock, flags);
  832.     }
  833.   else
  834.     {
  835.       DAC960_V2_ControllerInfo_T *ControllerInfo =
  836. &Controller->V2.ControllerInformation;
  837.       unsigned int StatusChangeCounter =
  838. Controller->V2.HealthStatusBuffer->StatusChangeCounter;
  839.       boolean ForceMonitoringCommand = false;
  840.       if (jiffies - Controller->SecondaryMonitoringTime
  841.   > DAC960_SecondaryMonitoringInterval)
  842. {
  843.   int LogicalDriveNumber;
  844.   for (LogicalDriveNumber = 0;
  845.        LogicalDriveNumber < DAC960_MaxLogicalDrives;
  846.        LogicalDriveNumber++)
  847.     {
  848.       DAC960_V2_LogicalDeviceInfo_T *LogicalDeviceInfo =
  849. Controller->V2.LogicalDeviceInformation[LogicalDriveNumber];
  850.       if (LogicalDeviceInfo == NULL) continue;
  851.       if (!LogicalDeviceInfo->LogicalDeviceControl
  852.      .LogicalDeviceInitialized)
  853. {
  854.   ForceMonitoringCommand = true;
  855.   break;
  856. }
  857.     }
  858.   Controller->SecondaryMonitoringTime = jiffies;
  859. }
  860.       if (StatusChangeCounter == Controller->V2.StatusChangeCounter &&
  861.   Controller->V2.HealthStatusBuffer->NextEventSequenceNumber
  862.   == Controller->V2.NextEventSequenceNumber &&
  863.   (ControllerInfo->BackgroundInitializationsActive +
  864.    ControllerInfo->LogicalDeviceInitializationsActive +
  865.    ControllerInfo->PhysicalDeviceInitializationsActive +
  866.    ControllerInfo->ConsistencyChecksActive +
  867.    ControllerInfo->RebuildsActive +
  868.    ControllerInfo->OnlineExpansionsActive == 0 ||
  869.    jiffies - Controller->PrimaryMonitoringTime
  870.    < DAC960_MonitoringTimerInterval) &&
  871.   !ForceMonitoringCommand)
  872. {
  873.   Controller->MonitoringTimer.expires =
  874.     jiffies + DAC960_HealthStatusMonitoringInterval;
  875.     add_timer(&Controller->MonitoringTimer);
  876.   return;
  877. }
  878.       Controller->V2.StatusChangeCounter = StatusChangeCounter;
  879.       Controller->PrimaryMonitoringTime = jiffies;
  881.       spin_lock_irqsave(&Controller->queue_lock, flags);
  882.       /*
  883. Queue a Status Monitoring Command to Controller.
  884.       */
  885.       Command = DAC960_AllocateCommand(Controller);
  886.       if (Command != NULL)
  887. DAC960_V2_QueueMonitoringCommand(Command);
  888.       else Controller->MonitoringCommandDeferred = true;
  889.       spin_unlock_irqrestore(&Controller->queue_lock, flags);
  890.       /*
  891. Wake up any processes waiting on a Health Status Buffer change.
  892.       */
  893.       wake_up(&Controller->HealthStatusWaitQueue);
  894.     }
  895. }
  897. /*
  898.   DAC960_CheckStatusBuffer verifies that there is room to hold ByteCount
  899.   additional bytes in the Combined Status Buffer and grows the buffer if
  900.   necessary.  It returns true if there is enough room and false otherwise.
  901. */
  903. static boolean DAC960_CheckStatusBuffer(DAC960_Controller_T *Controller,
  904. unsigned int ByteCount)
  905. {
  906.   unsigned char *NewStatusBuffer;
  907.   if (Controller->InitialStatusLength + 1 +
  908.       Controller->CurrentStatusLength + ByteCount + 1 <=
  909.       Controller->CombinedStatusBufferLength)
  910.     return true;
  911.   if (Controller->CombinedStatusBufferLength == 0)
  912.     {
  913.       unsigned int NewStatusBufferLength = DAC960_InitialStatusBufferSize;
  914.       while (NewStatusBufferLength < ByteCount)
  915. NewStatusBufferLength *= 2;
  916.       Controller->CombinedStatusBuffer =
  917. (unsigned char *) kmalloc(NewStatusBufferLength, GFP_ATOMIC);
  918.       if (Controller->CombinedStatusBuffer == NULL) return false;
  919.       Controller->CombinedStatusBufferLength = NewStatusBufferLength;
  920.       return true;
  921.     }
  922.   NewStatusBuffer = (unsigned char *)
  923.     kmalloc(2 * Controller->CombinedStatusBufferLength, GFP_ATOMIC);
  924.   if (NewStatusBuffer == NULL)
  925.     {
  926.       DAC960_Warning("Unable to expand Combined Status Buffer - Truncatingn",
  927.      Controller);
  928.       return false;
  929.     }
  930.   memcpy(NewStatusBuffer, Controller->CombinedStatusBuffer,
  931.  Controller->CombinedStatusBufferLength);
  932.   kfree(Controller->CombinedStatusBuffer);
  933.   Controller->CombinedStatusBuffer = NewStatusBuffer;
  934.   Controller->CombinedStatusBufferLength *= 2;
  935.   Controller->CurrentStatusBuffer =
  936.     &NewStatusBuffer[Controller->InitialStatusLength + 1];
  937.   return true;
  938. }
  941. /*
  942.   DAC960_Message prints Driver Messages.
  943. */
  945. static void DAC960_Message(DAC960_MessageLevel_T MessageLevel,
  946.    unsigned char *Format,
  947.    DAC960_Controller_T *Controller,
  948.    ...)
  949. {
  950.   static unsigned char Buffer[DAC960_LineBufferSize];
  951.   static boolean BeginningOfLine = true;
  952.   va_list Arguments;
  953.   int Length = 0;
  954.   va_start(Arguments, Controller);
  955.   Length = vsprintf(Buffer, Format, Arguments);
  956.   va_end(Arguments);
  957.   if (Controller == NULL)
  958.     printk("%sDAC960#%d: %s", DAC960_MessageLevelMap[MessageLevel],
  959.    DAC960_ControllerCount, Buffer);
  960.   else if (MessageLevel == DAC960_AnnounceLevel ||
  961.    MessageLevel == DAC960_InfoLevel)
  962.     {
  963.       if (!Controller->ControllerInitialized)
  964. {
  965.   if (DAC960_CheckStatusBuffer(Controller, Length))
  966.     {
  967.       strcpy(&Controller->CombinedStatusBuffer
  968.   [Controller->InitialStatusLength],
  969.      Buffer);
  970.       Controller->InitialStatusLength += Length;
  971.       Controller->CurrentStatusBuffer =
  972. &Controller->CombinedStatusBuffer
  973.      [Controller->InitialStatusLength + 1];
  974.     }
  975.   if (MessageLevel == DAC960_AnnounceLevel)
  976.     {
  977.       static int AnnouncementLines = 0;
  978.       if (++AnnouncementLines <= 2)
  979. printk("%sDAC960: %s", DAC960_MessageLevelMap[MessageLevel],
  980.        Buffer);
  981.     }
  982.   else
  983.     {
  984.       if (BeginningOfLine)
  985. {
  986.   if (Buffer[0] != 'n' || Length > 1)
  987.     printk("%sDAC960#%d: %s",
  988.    DAC960_MessageLevelMap[MessageLevel],
  989.    Controller->ControllerNumber, Buffer);
  990. }
  991.       else printk("%s", Buffer);
  992.     }
  993. }
  994.       else if (DAC960_CheckStatusBuffer(Controller, Length))
  995. {
  996.   strcpy(&Controller->CurrentStatusBuffer[
  997.     Controller->CurrentStatusLength], Buffer);
  998.   Controller->CurrentStatusLength += Length;
  999. }
  1000.     }
  1001.   else if (MessageLevel == DAC960_ProgressLevel)
  1002.     {
  1003.       strcpy(Controller->ProgressBuffer, Buffer);
  1004.       Controller->ProgressBufferLength = Length;
  1005.       if (Controller->EphemeralProgressMessage)
  1006. {
  1007.   if (jiffies - Controller->LastProgressReportTime
  1008.       >= DAC960_ProgressReportingInterval)
  1009.     {
  1010.       printk("%sDAC960#%d: %s", DAC960_MessageLevelMap[MessageLevel],
  1011.      Controller->ControllerNumber, Buffer);
  1012.       Controller->LastProgressReportTime = jiffies;
  1013.     }
  1014. }
  1015.       else printk("%sDAC960#%d: %s", DAC960_MessageLevelMap[MessageLevel],
  1016.   Controller->ControllerNumber, Buffer);
  1017.     }
  1018.   else if (MessageLevel == DAC960_UserCriticalLevel)
  1019.     {
  1020.       strcpy(&Controller->UserStatusBuffer[Controller->UserStatusLength],
  1021.      Buffer);
  1022.       Controller->UserStatusLength += Length;
  1023.       if (Buffer[0] != 'n' || Length > 1)
  1024. printk("%sDAC960#%d: %s", DAC960_MessageLevelMap[MessageLevel],
  1025.        Controller->ControllerNumber, Buffer);
  1026.     }
  1027.   else
  1028.     {
  1029.       if (BeginningOfLine)
  1030. printk("%sDAC960#%d: %s", DAC960_MessageLevelMap[MessageLevel],
  1031.        Controller->ControllerNumber, Buffer);
  1032.       else printk("%s", Buffer);
  1033.     }
  1034.   BeginningOfLine = (Buffer[Length-1] == 'n');
  1035. }
  1038. /*
  1039.   DAC960_ParsePhysicalDevice parses spaces followed by a Physical Device
  1040.   Channel:TargetID specification from a User Command string.  It updates
  1041.   Channel and TargetID and returns true on success and false on failure.
  1042. */
  1044. static boolean DAC960_ParsePhysicalDevice(DAC960_Controller_T *Controller,
  1045.   char *UserCommandString,
  1046.   unsigned char *Channel,
  1047.   unsigned char *TargetID)
  1048. {
  1049.   char *NewUserCommandString = UserCommandString;
  1050.   unsigned long XChannel, XTargetID;
  1051.   while (*UserCommandString == ' ') UserCommandString++;
  1052.   if (UserCommandString == NewUserCommandString)
  1053.     return false;
  1054.   XChannel = simple_strtoul(UserCommandString, &NewUserCommandString, 10);
  1055.   if (NewUserCommandString == UserCommandString ||
  1056.       *NewUserCommandString != ':' ||
  1057.       XChannel >= Controller->Channels)
  1058.     return false;
  1059.   UserCommandString = ++NewUserCommandString;
  1060.   XTargetID = simple_strtoul(UserCommandString, &NewUserCommandString, 10);
  1061.   if (NewUserCommandString == UserCommandString ||
  1062.       *NewUserCommandString != '' ||
  1063.       XTargetID >= Controller->Targets)
  1064.     return false;
  1065.   *Channel = XChannel;
  1066.   *TargetID = XTargetID;
  1067.   return true;
  1068. }
  1071. /*
  1072.   DAC960_ParseLogicalDrive parses spaces followed by a Logical Drive Number
  1073.   specification from a User Command string.  It updates LogicalDriveNumber and
  1074.   returns true on success and false on failure.
  1075. */
  1077. static boolean DAC960_ParseLogicalDrive(DAC960_Controller_T *Controller,
  1078. char *UserCommandString,
  1079. unsigned char *LogicalDriveNumber)
  1080. {
  1081.   char *NewUserCommandString = UserCommandString;
  1082.   unsigned long XLogicalDriveNumber;
  1083.   while (*UserCommandString == ' ') UserCommandString++;
  1084.   if (UserCommandString == NewUserCommandString)
  1085.     return false;
  1086.   XLogicalDriveNumber =
  1087.     simple_strtoul(UserCommandString, &NewUserCommandString, 10);
  1088.   if (NewUserCommandString == UserCommandString ||
  1089.       *NewUserCommandString != '' ||
  1090.       XLogicalDriveNumber > DAC960_MaxLogicalDrives - 1)
  1091.     return false;
  1092.   *LogicalDriveNumber = XLogicalDriveNumber;
  1093.   return true;
  1094. }
  1097. /*
  1098.   DAC960_V1_SetDeviceState sets the Device State for a Physical Device for
  1099.   DAC960 V1 Firmware Controllers.
  1100. */
  1102. static void DAC960_V1_SetDeviceState(DAC960_Controller_T *Controller,
  1103.      DAC960_Command_T *Command,
  1104.      unsigned char Channel,
  1105.      unsigned char TargetID,
  1106.      DAC960_V1_PhysicalDeviceState_T
  1107.        DeviceState,
  1108.      const unsigned char *DeviceStateString)
  1109. {
  1110.   DAC960_V1_CommandMailbox_T *CommandMailbox = &Command->V1.CommandMailbox;
  1111.   CommandMailbox->Type3D.CommandOpcode = DAC960_V1_StartDevice;
  1112.   CommandMailbox->Type3D.Channel = Channel;
  1113.   CommandMailbox->Type3D.TargetID = TargetID;
  1114.   CommandMailbox->Type3D.DeviceState = DeviceState;
  1115.   CommandMailbox->Type3D.Modifier = 0;
  1116.   DAC960_ExecuteCommand(Command);
  1117.   switch (Command->V1.CommandStatus)
  1118.     {
  1119.     case DAC960_V1_NormalCompletion:
  1120.       DAC960_UserCritical("%s of Physical Device %d:%d Succeededn", Controller,
  1121.   DeviceStateString, Channel, TargetID);
  1122.       break;
  1123.     case DAC960_V1_UnableToStartDevice:
  1124.       DAC960_UserCritical("%s of Physical Device %d:%d Failed - "
  1125.   "Unable to Start Devicen", Controller,
  1126.   DeviceStateString, Channel, TargetID);
  1127.       break;
  1128.     case DAC960_V1_NoDeviceAtAddress:
  1129.       DAC960_UserCritical("%s of Physical Device %d:%d Failed - "
  1130.   "No Device at Addressn", Controller,
  1131.   DeviceStateString, Channel, TargetID);
  1132.       break;
  1133.     case DAC960_V1_InvalidChannelOrTargetOrModifier:
  1134.       DAC960_UserCritical("%s of Physical Device %d:%d Failed - "
  1135.   "Invalid Channel or Target or Modifiern",
  1136.   Controller, DeviceStateString, Channel, TargetID);
  1137.       break;
  1138.     case DAC960_V1_ChannelBusy:
  1139.       DAC960_UserCritical("%s of Physical Device %d:%d Failed - "
  1140.   "Channel Busyn", Controller,
  1141.   DeviceStateString, Channel, TargetID);
  1142.       break;
  1143.     default:
  1144.       DAC960_UserCritical("%s of Physical Device %d:%d Failed - "
  1145.   "Unexpected Status %04Xn", Controller,
  1146.   DeviceStateString, Channel, TargetID,
  1147.   Command->V1.CommandStatus);
  1148.       break;
  1149.     }
  1150. }
  1153. /*
  1154.   DAC960_V1_ExecuteUserCommand executes a User Command for DAC960 V1 Firmware
  1155.   Controllers.
  1156. */
  1158. static boolean DAC960_V1_ExecuteUserCommand(DAC960_Controller_T *Controller,
  1159.     unsigned char *UserCommand)
  1160. {
  1161.   DAC960_Command_T *Command;
  1162.   DAC960_V1_CommandMailbox_T *CommandMailbox;
  1163.   unsigned long flags;
  1164.   unsigned char Channel, TargetID, LogicalDriveNumber;
  1166.   spin_lock_irqsave(&Controller->queue_lock, flags);
  1167.   while ((Command = DAC960_AllocateCommand(Controller)) == NULL)
  1168.     DAC960_WaitForCommand(Controller);
  1169.   spin_unlock_irqrestore(&Controller->queue_lock, flags);
  1170.   Controller->UserStatusLength = 0;
  1171.   DAC960_V1_ClearCommand(Command);
  1172.   Command->CommandType = DAC960_ImmediateCommand;
  1173.   CommandMailbox = &Command->V1.CommandMailbox;
  1174.   if (strcmp(UserCommand, "flush-cache") == 0)
  1175.     {
  1176.       CommandMailbox->Type3.CommandOpcode = DAC960_V1_Flush;
  1177.       DAC960_ExecuteCommand(Command);
  1178.       DAC960_UserCritical("Cache Flush Completedn", Controller);
  1179.     }
  1180.   else if (strncmp(UserCommand, "kill", 4) == 0 &&
  1181.    DAC960_ParsePhysicalDevice(Controller, &UserCommand[4],
  1182.       &Channel, &TargetID))
  1183.     {
  1184.       DAC960_V1_DeviceState_T *DeviceState =
  1185. &Controller->V1.DeviceState[Channel][TargetID];
  1186.       if (DeviceState->Present &&
  1187.   DeviceState->DeviceType == DAC960_V1_DiskType &&
  1188.   DeviceState->DeviceState != DAC960_V1_Device_Dead)
  1189. DAC960_V1_SetDeviceState(Controller, Command, Channel, TargetID,
  1190.  DAC960_V1_Device_Dead, "Kill");
  1191.       else DAC960_UserCritical("Kill of Physical Device %d:%d Illegaln",
  1192.        Controller, Channel, TargetID);
  1193.     }
  1194.   else if (strncmp(UserCommand, "make-online", 11) == 0 &&
  1195.    DAC960_ParsePhysicalDevice(Controller, &UserCommand[11],
  1196.       &Channel, &TargetID))
  1197.     {
  1198.       DAC960_V1_DeviceState_T *DeviceState =
  1199. &Controller->V1.DeviceState[Channel][TargetID];
  1200.       if (DeviceState->Present &&
  1201.   DeviceState->DeviceType == DAC960_V1_DiskType &&
  1202.   DeviceState->DeviceState == DAC960_V1_Device_Dead)
  1203. DAC960_V1_SetDeviceState(Controller, Command, Channel, TargetID,
  1204.  DAC960_V1_Device_Online, "Make Online");
  1205.       else DAC960_UserCritical("Make Online of Physical Device %d:%d Illegaln",
  1206.        Controller, Channel, TargetID);
  1208.     }
  1209.   else if (strncmp(UserCommand, "make-standby", 12) == 0 &&
  1210.    DAC960_ParsePhysicalDevice(Controller, &UserCommand[12],
  1211.       &Channel, &TargetID))
  1212.     {
  1213.       DAC960_V1_DeviceState_T *DeviceState =
  1214. &Controller->V1.DeviceState[Channel][TargetID];
  1215.       if (DeviceState->Present &&
  1216.   DeviceState->DeviceType == DAC960_V1_DiskType &&
  1217.   DeviceState->DeviceState == DAC960_V1_Device_Dead)
  1218. DAC960_V1_SetDeviceState(Controller, Command, Channel, TargetID,
  1219.  DAC960_V1_Device_Standby, "Make Standby");
  1220.       else DAC960_UserCritical("Make Standby of Physical "
  1221.        "Device %d:%d Illegaln",
  1222.        Controller, Channel, TargetID);
  1223.     }
  1224.   else if (strncmp(UserCommand, "rebuild", 7) == 0 &&
  1225.    DAC960_ParsePhysicalDevice(Controller, &UserCommand[7],
  1226.       &Channel, &TargetID))
  1227.     {
  1228.       CommandMailbox->Type3D.CommandOpcode = DAC960_V1_RebuildAsync;
  1229.       CommandMailbox->Type3D.Channel = Channel;
  1230.       CommandMailbox->Type3D.TargetID = TargetID;
  1231.       DAC960_ExecuteCommand(Command);
  1232.       switch (Command->V1.CommandStatus)
  1233. {
  1234. case DAC960_V1_NormalCompletion:
  1235.   DAC960_UserCritical("Rebuild of Physical Device %d:%d Initiatedn",
  1236.       Controller, Channel, TargetID);
  1237.   break;
  1238. case DAC960_V1_AttemptToRebuildOnlineDrive:
  1239.   DAC960_UserCritical("Rebuild of Physical Device %d:%d Failed - "
  1240.       "Attempt to Rebuild Online or "
  1241.       "Unresponsive Driven",
  1242.       Controller, Channel, TargetID);
  1243.   break;
  1244. case DAC960_V1_NewDiskFailedDuringRebuild:
  1245.   DAC960_UserCritical("Rebuild of Physical Device %d:%d Failed - "
  1246.       "New Disk Failed During Rebuildn",
  1247.       Controller, Channel, TargetID);
  1248.   break;
  1249. case DAC960_V1_InvalidDeviceAddress:
  1250.   DAC960_UserCritical("Rebuild of Physical Device %d:%d Failed - "
  1251.       "Invalid Device Addressn",
  1252.       Controller, Channel, TargetID);
  1253.   break;
  1254. case DAC960_V1_RebuildOrCheckAlreadyInProgress:
  1255.   DAC960_UserCritical("Rebuild of Physical Device %d:%d Failed - "
  1256.       "Rebuild or Consistency Check Already "
  1257.       "in Progressn", Controller, Channel, TargetID);
  1258.   break;
  1259. default:
  1260.   DAC960_UserCritical("Rebuild of Physical Device %d:%d Failed - "
  1261.       "Unexpected Status %04Xn", Controller,
  1262.       Channel, TargetID, Command->V1.CommandStatus);
  1263.   break;
  1264. }
  1265.     }
  1266.   else if (strncmp(UserCommand, "check-consistency", 17) == 0 &&
  1267.    DAC960_ParseLogicalDrive(Controller, &UserCommand[17],
  1268.     &LogicalDriveNumber))
  1269.     {
  1270.       CommandMailbox->Type3C.CommandOpcode = DAC960_V1_CheckConsistencyAsync;
  1271.       CommandMailbox->Type3C.LogicalDriveNumber = LogicalDriveNumber;
  1272.       CommandMailbox->Type3C.AutoRestore = true;
  1273.       DAC960_ExecuteCommand(Command);
  1274.       switch (Command->V1.CommandStatus)
  1275. {
  1276. case DAC960_V1_NormalCompletion:
  1277.   DAC960_UserCritical("Consistency Check of Logical Drive %d "
  1278.       "(/dev/rd/c%dd%d) Initiatedn",
  1279.       Controller, LogicalDriveNumber,
  1280.       Controller->ControllerNumber,
  1281.       LogicalDriveNumber);
  1282.   break;
  1283. case DAC960_V1_DependentDiskIsDead:
  1284.   DAC960_UserCritical("Consistency Check of Logical Drive %d "
  1285.       "(/dev/rd/c%dd%d) Failed - "
  1286.       "Dependent Physical Device is DEADn",
  1287.       Controller, LogicalDriveNumber,
  1288.       Controller->ControllerNumber,
  1289.       LogicalDriveNumber);
  1290.   break;
  1291. case DAC960_V1_InvalidOrNonredundantLogicalDrive:
  1292.   DAC960_UserCritical("Consistency Check of Logical Drive %d "
  1293.       "(/dev/rd/c%dd%d) Failed - "
  1294.       "Invalid or Nonredundant Logical Driven",
  1295.       Controller, LogicalDriveNumber,
  1296.       Controller->ControllerNumber,
  1297.       LogicalDriveNumber);
  1298.   break;
  1299. case DAC960_V1_RebuildOrCheckAlreadyInProgress:
  1300.   DAC960_UserCritical("Consistency Check of Logical Drive %d "
  1301.       "(/dev/rd/c%dd%d) Failed - Rebuild or "
  1302.       "Consistency Check Already in Progressn",
  1303.       Controller, LogicalDriveNumber,
  1304.       Controller->ControllerNumber,
  1305.       LogicalDriveNumber);
  1306.   break;
  1307. default:
  1308.   DAC960_UserCritical("Consistency Check of Logical Drive %d "
  1309.       "(/dev/rd/c%dd%d) Failed - "
  1310.       "Unexpected Status %04Xn",
  1311.       Controller, LogicalDriveNumber,
  1312.       Controller->ControllerNumber,
  1313.       LogicalDriveNumber, Command->V1.CommandStatus);
  1314.   break;
  1315. }
  1316.     }
  1317.   else if (strcmp(UserCommand, "cancel-rebuild") == 0 ||
  1318.    strcmp(UserCommand, "cancel-consistency-check") == 0)
  1319.     {
  1320.       /*
  1321.         the OldRebuildRateConstant is never actually used
  1322.         once its value is retrieved from the controller.
  1323.        */
  1324.       unsigned char *OldRebuildRateConstant;
  1325.       dma_addr_t OldRebuildRateConstantDMA;
  1327.       OldRebuildRateConstant = pci_alloc_consistent( Controller->PCIDevice,
  1328. sizeof(char), &OldRebuildRateConstantDMA);
  1329.       if (OldRebuildRateConstant == NULL) {
  1330.          DAC960_UserCritical("Cancellation of Rebuild or "
  1331.      "Consistency Check Failed - "
  1332.      "Out of Memory",
  1333.                              Controller);
  1334.  goto failure;
  1335.       }
  1336.       CommandMailbox->Type3R.CommandOpcode = DAC960_V1_RebuildControl;
  1337.       CommandMailbox->Type3R.RebuildRateConstant = 0xFF;
  1338.       CommandMailbox->Type3R.BusAddress = OldRebuildRateConstantDMA;
  1339.       DAC960_ExecuteCommand(Command);
  1340.       switch (Command->V1.CommandStatus)
  1341. {
  1342. case DAC960_V1_NormalCompletion:
  1343.   DAC960_UserCritical("Rebuild or Consistency Check Cancelledn",
  1344.       Controller);
  1345.   break;
  1346. default:
  1347.   DAC960_UserCritical("Cancellation of Rebuild or "
  1348.       "Consistency Check Failed - "
  1349.       "Unexpected Status %04Xn",
  1350.       Controller, Command->V1.CommandStatus);
  1351.   break;
  1352. }
  1353. failure:
  1354.    pci_free_consistent(Controller->PCIDevice, sizeof(char),
  1355. OldRebuildRateConstant, OldRebuildRateConstantDMA);
  1356.     }
  1357.   else DAC960_UserCritical("Illegal User Command: '%s'n",
  1358.    Controller, UserCommand);
  1360.   spin_lock_irqsave(&Controller->queue_lock, flags);
  1361.   DAC960_DeallocateCommand(Command);
  1362.   spin_unlock_irqrestore(&Controller->queue_lock, flags);
  1363.   return true;
  1364. }
  1367. /*
  1368.   DAC960_V2_TranslatePhysicalDevice translates a Physical Device Channel and
  1369.   TargetID into a Logical Device.  It returns true on success and false
  1370.   on failure.
  1371. */
  1373. static boolean DAC960_V2_TranslatePhysicalDevice(DAC960_Command_T *Command,
  1374.  unsigned char Channel,
  1375.  unsigned char TargetID,
  1376.  unsigned short
  1377.    *LogicalDeviceNumber)
  1378. {
  1379.   DAC960_V2_CommandMailbox_T SavedCommandMailbox, *CommandMailbox;
  1380.   DAC960_Controller_T *Controller =  Command->Controller;
  1382.   CommandMailbox = &Command->V2.CommandMailbox;
  1383.   memcpy(&SavedCommandMailbox, CommandMailbox,
  1384.  sizeof(DAC960_V2_CommandMailbox_T));
  1386.   CommandMailbox->PhysicalDeviceInfo.CommandOpcode = DAC960_V2_IOCTL;
  1387.   CommandMailbox->PhysicalDeviceInfo.CommandControlBits
  1388.     .DataTransferControllerToHost = true;
  1389.   CommandMailbox->PhysicalDeviceInfo.CommandControlBits
  1390.     .NoAutoRequestSense = true;
  1391.   CommandMailbox->PhysicalDeviceInfo.DataTransferSize =
  1392.     sizeof(DAC960_V2_PhysicalToLogicalDevice_T);
  1393.   CommandMailbox->PhysicalDeviceInfo.PhysicalDevice.TargetID = TargetID;
  1394.   CommandMailbox->PhysicalDeviceInfo.PhysicalDevice.Channel = Channel;
  1395.   CommandMailbox->PhysicalDeviceInfo.IOCTL_Opcode =
  1396.     DAC960_V2_TranslatePhysicalToLogicalDevice;
  1397.   CommandMailbox->Common.DataTransferMemoryAddress
  1398. .ScatterGatherSegments[0]
  1399. .SegmentDataPointer =
  1400.      Controller->V2.PhysicalToLogicalDeviceDMA;
  1401.   CommandMailbox->Common.DataTransferMemoryAddress
  1402. .ScatterGatherSegments[0]
  1403. .SegmentByteCount =
  1404.      CommandMailbox->Common.DataTransferSize;
  1406.   DAC960_ExecuteCommand(Command);
  1407.   *LogicalDeviceNumber = Controller->V2.PhysicalToLogicalDevice->LogicalDeviceNumber;
  1409.   memcpy(CommandMailbox, &SavedCommandMailbox,
  1410.  sizeof(DAC960_V2_CommandMailbox_T));
  1411.   return (Command->V2.CommandStatus == DAC960_V2_NormalCompletion);
  1412. }
  1415. /*
  1416.   DAC960_V2_ExecuteUserCommand executes a User Command for DAC960 V2 Firmware
  1417.   Controllers.
  1418. */
  1420. static boolean DAC960_V2_ExecuteUserCommand(DAC960_Controller_T *Controller,
  1421.     unsigned char *UserCommand)
  1422. {
  1423.   DAC960_Command_T *Command;
  1424.   DAC960_V2_CommandMailbox_T *CommandMailbox;
  1425.   unsigned long flags;
  1426.   unsigned char Channel, TargetID, LogicalDriveNumber;
  1427.   unsigned short LogicalDeviceNumber;
  1429.   spin_lock_irqsave(&Controller->queue_lock, flags);
  1430.   while ((Command = DAC960_AllocateCommand(Controller)) == NULL)
  1431.     DAC960_WaitForCommand(Controller);
  1432.   spin_unlock_irqrestore(&Controller->queue_lock, flags);
  1433.   Controller->UserStatusLength = 0;
  1434.   DAC960_V2_ClearCommand(Command);
  1435.   Command->CommandType = DAC960_ImmediateCommand;
  1436.   CommandMailbox = &Command->V2.CommandMailbox;
  1437.   CommandMailbox->Common.CommandOpcode = DAC960_V2_IOCTL;
  1438.   CommandMailbox->Common.CommandControlBits.DataTransferControllerToHost = true;
  1439.   CommandMailbox->Common.CommandControlBits.NoAutoRequestSense = true;
  1440.   if (strcmp(UserCommand, "flush-cache") == 0)
  1441.     {
  1442.       CommandMailbox->DeviceOperation.IOCTL_Opcode = DAC960_V2_PauseDevice;
  1443.       CommandMailbox->DeviceOperation.OperationDevice =
  1444. DAC960_V2_RAID_Controller;
  1445.       DAC960_ExecuteCommand(Command);
  1446.       DAC960_UserCritical("Cache Flush Completedn", Controller);
  1447.     }
  1448.   else if (strncmp(UserCommand, "kill", 4) == 0 &&
  1449.    DAC960_ParsePhysicalDevice(Controller, &UserCommand[4],
  1450.       &Channel, &TargetID) &&
  1451.    DAC960_V2_TranslatePhysicalDevice(Command, Channel, TargetID,
  1452.      &LogicalDeviceNumber))
  1453.     {
  1454.       CommandMailbox->SetDeviceState.LogicalDevice.LogicalDeviceNumber =
  1455. LogicalDeviceNumber;
  1456.       CommandMailbox->SetDeviceState.IOCTL_Opcode =
  1457. DAC960_V2_SetDeviceState;
  1458.       CommandMailbox->SetDeviceState.DeviceState.PhysicalDeviceState =
  1459. DAC960_V2_Device_Dead;
  1460.       DAC960_ExecuteCommand(Command);
  1461.       DAC960_UserCritical("Kill of Physical Device %d:%d %sn",
  1462.   Controller, Channel, TargetID,
  1463.   (Command->V2.CommandStatus
  1464.    == DAC960_V2_NormalCompletion
  1465.    ? "Succeeded" : "Failed"));
  1466.     }
  1467.   else if (strncmp(UserCommand, "make-online", 11) == 0 &&
  1468.    DAC960_ParsePhysicalDevice(Controller, &UserCommand[11],
  1469.       &Channel, &TargetID) &&
  1470.    DAC960_V2_TranslatePhysicalDevice(Command, Channel, TargetID,
  1471.      &LogicalDeviceNumber))
  1472.     {
  1473.       CommandMailbox->SetDeviceState.LogicalDevice.LogicalDeviceNumber =
  1474. LogicalDeviceNumber;
  1475.       CommandMailbox->SetDeviceState.IOCTL_Opcode =
  1476. DAC960_V2_SetDeviceState;
  1477.       CommandMailbox->SetDeviceState.DeviceState.PhysicalDeviceState =
  1478. DAC960_V2_Device_Online;
  1479.       DAC960_ExecuteCommand(Command);
  1480.       DAC960_UserCritical("Make Online of Physical Device %d:%d %sn",
  1481.   Controller, Channel, TargetID,
  1482.   (Command->V2.CommandStatus
  1483.    == DAC960_V2_NormalCompletion
  1484.    ? "Succeeded" : "Failed"));
  1485.     }
  1486.   else if (strncmp(UserCommand, "make-standby", 12) == 0 &&
  1487.    DAC960_ParsePhysicalDevice(Controller, &UserCommand[12],
  1488.       &Channel, &TargetID) &&
  1489.    DAC960_V2_TranslatePhysicalDevice(Command, Channel, TargetID,
  1490.      &LogicalDeviceNumber))
  1491.     {
  1492.       CommandMailbox->SetDeviceState.LogicalDevice.LogicalDeviceNumber =
  1493. LogicalDeviceNumber;
  1494.       CommandMailbox->SetDeviceState.IOCTL_Opcode =
  1495. DAC960_V2_SetDeviceState;
  1496.       CommandMailbox->SetDeviceState.DeviceState.PhysicalDeviceState =
  1497. DAC960_V2_Device_Standby;
  1498.       DAC960_ExecuteCommand(Command);
  1499.       DAC960_UserCritical("Make Standby of Physical Device %d:%d %sn",
  1500.   Controller, Channel, TargetID,
  1501.   (Command->V2.CommandStatus
  1502.    == DAC960_V2_NormalCompletion
  1503.    ? "Succeeded" : "Failed"));
  1504.     }
  1505.   else if (strncmp(UserCommand, "rebuild", 7) == 0 &&
  1506.    DAC960_ParsePhysicalDevice(Controller, &UserCommand[7],
  1507.       &Channel, &TargetID) &&
  1508.    DAC960_V2_TranslatePhysicalDevice(Command, Channel, TargetID,
  1509.      &LogicalDeviceNumber))
  1510.     {
  1511.       CommandMailbox->LogicalDeviceInfo.LogicalDevice.LogicalDeviceNumber =
  1512. LogicalDeviceNumber;
  1513.       CommandMailbox->LogicalDeviceInfo.IOCTL_Opcode =
  1514. DAC960_V2_RebuildDeviceStart;
  1515.       DAC960_ExecuteCommand(Command);
  1516.       DAC960_UserCritical("Rebuild of Physical Device %d:%d %sn",
  1517.   Controller, Channel, TargetID,
  1518.   (Command->V2.CommandStatus
  1519.    == DAC960_V2_NormalCompletion
  1520.    ? "Initiated" : "Not Initiated"));
  1521.     }
  1522.   else if (strncmp(UserCommand, "cancel-rebuild", 14) == 0 &&
  1523.    DAC960_ParsePhysicalDevice(Controller, &UserCommand[14],
  1524.       &Channel, &TargetID) &&
  1525.    DAC960_V2_TranslatePhysicalDevice(Command, Channel, TargetID,
  1526.      &LogicalDeviceNumber))
  1527.     {
  1528.       CommandMailbox->LogicalDeviceInfo.LogicalDevice.LogicalDeviceNumber =
  1529. LogicalDeviceNumber;
  1530.       CommandMailbox->LogicalDeviceInfo.IOCTL_Opcode =
  1531. DAC960_V2_RebuildDeviceStop;
  1532.       DAC960_ExecuteCommand(Command);
  1533.       DAC960_UserCritical("Rebuild of Physical Device %d:%d %sn",
  1534.   Controller, Channel, TargetID,
  1535.   (Command->V2.CommandStatus
  1536.    == DAC960_V2_NormalCompletion
  1537.    ? "Cancelled" : "Not Cancelled"));
  1538.     }
  1539.   else if (strncmp(UserCommand, "check-consistency", 17) == 0 &&
  1540.    DAC960_ParseLogicalDrive(Controller, &UserCommand[17],
  1541.     &LogicalDriveNumber))
  1542.     {
  1543.       CommandMailbox->ConsistencyCheck.LogicalDevice.LogicalDeviceNumber =
  1544. LogicalDriveNumber;
  1545.       CommandMailbox->ConsistencyCheck.IOCTL_Opcode =
  1546. DAC960_V2_ConsistencyCheckStart;
  1547.       CommandMailbox->ConsistencyCheck.RestoreConsistency = true;
  1548.       CommandMailbox->ConsistencyCheck.InitializedAreaOnly = false;
  1549.       DAC960_ExecuteCommand(Command);
  1550.       DAC960_UserCritical("Consistency Check of Logical Drive %d "
  1551.   "(/dev/rd/c%dd%d) %sn",
  1552.   Controller, LogicalDriveNumber,
  1553.   Controller->ControllerNumber,
  1554.   LogicalDriveNumber,
  1555.   (Command->V2.CommandStatus
  1556.    == DAC960_V2_NormalCompletion
  1557.    ? "Initiated" : "Not Initiated"));
  1558.     }
  1559.   else if (strncmp(UserCommand, "cancel-consistency-check", 24) == 0 &&
  1560.    DAC960_ParseLogicalDrive(Controller, &UserCommand[24],
  1561.     &LogicalDriveNumber))
  1562.     {
  1563.       CommandMailbox->ConsistencyCheck.LogicalDevice.LogicalDeviceNumber =
  1564. LogicalDriveNumber;
  1565.       CommandMailbox->ConsistencyCheck.IOCTL_Opcode =
  1566. DAC960_V2_ConsistencyCheckStop;
  1567.       DAC960_ExecuteCommand(Command);
  1568.       DAC960_UserCritical("Consistency Check of Logical Drive %d "
  1569.   "(/dev/rd/c%dd%d) %sn",
  1570.   Controller, LogicalDriveNumber,
  1571.   Controller->ControllerNumber,
  1572.   LogicalDriveNumber,
  1573.   (Command->V2.CommandStatus
  1574.    == DAC960_V2_NormalCompletion
  1575.    ? "Cancelled" : "Not Cancelled"));
  1576.     }
  1577.   else if (strcmp(UserCommand, "perform-discovery") == 0)
  1578.     {
  1579.       CommandMailbox->Common.IOCTL_Opcode = DAC960_V2_StartDiscovery;
  1580.       DAC960_ExecuteCommand(Command);
  1581.       DAC960_UserCritical("Discovery %sn", Controller,
  1582.   (Command->V2.CommandStatus
  1583.    == DAC960_V2_NormalCompletion
  1584.    ? "Initiated" : "Not Initiated"));
  1585.       if (Command->V2.CommandStatus == DAC960_V2_NormalCompletion)
  1586. {
  1587.   CommandMailbox->ControllerInfo.CommandOpcode = DAC960_V2_IOCTL;
  1588.   CommandMailbox->ControllerInfo.CommandControlBits
  1589. .DataTransferControllerToHost = true;
  1590.   CommandMailbox->ControllerInfo.CommandControlBits
  1591. .NoAutoRequestSense = true;
  1592.   CommandMailbox->ControllerInfo.DataTransferSize =
  1593.     sizeof(DAC960_V2_ControllerInfo_T);
  1594.   CommandMailbox->ControllerInfo.ControllerNumber = 0;
  1595.   CommandMailbox->ControllerInfo.IOCTL_Opcode =
  1596.     DAC960_V2_GetControllerInfo;
  1597.   /*
  1598.    * How does this NOT race with the queued Monitoring
  1599.    * usage of this structure?
  1600.    */
  1601.   CommandMailbox->ControllerInfo.DataTransferMemoryAddress
  1602. .ScatterGatherSegments[0]
  1603. .SegmentDataPointer =
  1604.     Controller->V2.NewControllerInformationDMA;
  1605.   CommandMailbox->ControllerInfo.DataTransferMemoryAddress
  1606. .ScatterGatherSegments[0]
  1607. .SegmentByteCount =
  1608.     CommandMailbox->ControllerInfo.DataTransferSize;
  1609.   DAC960_ExecuteCommand(Command);
  1610.   while (Controller->V2.NewControllerInformation->PhysicalScanActive)
  1611.     {
  1612.       DAC960_ExecuteCommand(Command);
  1613.       sleep_on_timeout(&Controller->CommandWaitQueue, HZ);
  1614.     }
  1615.   DAC960_UserCritical("Discovery Completedn", Controller);
  1616.   }
  1617.     }
  1618.   else if (strcmp(UserCommand, "suppress-enclosure-messages") == 0)
  1619.     Controller->SuppressEnclosureMessages = true;
  1620.   else DAC960_UserCritical("Illegal User Command: '%s'n",
  1621.    Controller, UserCommand);
  1623.   spin_lock_irqsave(&Controller->queue_lock, flags);
  1624.   DAC960_DeallocateCommand(Command);
  1625.   spin_unlock_irqrestore(&Controller->queue_lock, flags);
  1626.   return true;
  1627. }
  1630. /*
  1631.   DAC960_ProcReadStatus implements reading /proc/rd/status.
  1632. */
  1634. static int DAC960_ProcReadStatus(char *Page, char **Start, off_t Offset,
  1635.  int Count, int *EOF, void *Data)
  1636. {
  1637.   unsigned char *StatusMessage = "OKn";
  1638.   int ControllerNumber, BytesAvailable;
  1639.   for (ControllerNumber = 0;
  1640.        ControllerNumber < DAC960_ControllerCount;
  1641.        ControllerNumber++)
  1642.     {
  1643.       DAC960_Controller_T *Controller = DAC960_Controllers[ControllerNumber];
  1644.       if (Controller == NULL) continue;
  1645.       if (Controller->MonitoringAlertMode)
  1646. {
  1647.   StatusMessage = "ALERTn";
  1648.   break;
  1649. }
  1650.     }
  1651.   BytesAvailable = strlen(StatusMessage) - Offset;
  1652.   if (Count >= BytesAvailable)
  1653.     {
  1654.       Count = BytesAvailable;
  1655.       *EOF = true;
  1656.     }
  1657.   if (Count <= 0) return 0;
  1658.   *Start = Page;
  1659.   memcpy(Page, &StatusMessage[Offset], Count);
  1660.   return Count;
  1661. }
  1664. /*
  1665.   DAC960_ProcReadInitialStatus implements reading /proc/rd/cN/initial_status.
  1666. */
  1668. static int DAC960_ProcReadInitialStatus(char *Page, char **Start, off_t Offset,
  1669. int Count, int *EOF, void *Data)
  1670. {
  1671.   DAC960_Controller_T *Controller = (DAC960_Controller_T *) Data;
  1672.   int BytesAvailable = Controller->InitialStatusLength - Offset;
  1673.   if (Count >= BytesAvailable)
  1674.     {
  1675.       Count = BytesAvailable;
  1676.       *EOF = true;
  1677.     }
  1678.   if (Count <= 0) return 0;
  1679.   *Start = Page;
  1680.   memcpy(Page, &Controller->CombinedStatusBuffer[Offset], Count);
  1681.   return Count;
  1682. }
  1685. /*
  1686.   DAC960_ProcReadCurrentStatus implements reading /proc/rd/cN/current_status.
  1687. */
  1689. static int DAC960_ProcReadCurrentStatus(char *Page, char **Start, off_t Offset,
  1690. int Count, int *EOF, void *Data)
  1691. {
  1692.   DAC960_Controller_T *Controller = (DAC960_Controller_T *) Data;
  1693.   unsigned char *StatusMessage =
  1694.     "No Rebuild or Consistency Check in Progressn";
  1695.   int ProgressMessageLength = strlen(StatusMessage);
  1696.   int BytesAvailable;
  1697.   if (jiffies != Controller->LastCurrentStatusTime)
  1698.     {
  1699.       Controller->CurrentStatusLength = 0;
  1700.       DAC960_AnnounceDriver(Controller);
  1701.       DAC960_ReportControllerConfiguration(Controller);
  1702.       DAC960_ReportDeviceConfiguration(Controller);
  1703.       if (Controller->ProgressBufferLength > 0)
  1704. ProgressMessageLength = Controller->ProgressBufferLength;
  1705.       if (DAC960_CheckStatusBuffer(Controller, 2 + ProgressMessageLength))
  1706. {
  1707.   unsigned char *CurrentStatusBuffer = Controller->CurrentStatusBuffer;
  1708.   CurrentStatusBuffer[Controller->CurrentStatusLength++] = ' ';
  1709.   CurrentStatusBuffer[Controller->CurrentStatusLength++] = ' ';
  1710.   if (Controller->ProgressBufferLength > 0)
  1711.     strcpy(&CurrentStatusBuffer[Controller->CurrentStatusLength],
  1712.    Controller->ProgressBuffer);
  1713.   else
  1714.     strcpy(&CurrentStatusBuffer[Controller->CurrentStatusLength],
  1715.    StatusMessage);
  1716.   Controller->CurrentStatusLength += ProgressMessageLength;
  1717. }
  1718.       Controller->LastCurrentStatusTime = jiffies;
  1719.     }
  1720.   BytesAvailable = Controller->CurrentStatusLength - Offset;
  1721.   if (Count >= BytesAvailable)
  1722.     {
  1723.       Count = BytesAvailable;
  1724.       *EOF = true;
  1725.     }
  1726.   if (Count <= 0) return 0;
  1727.   *Start = Page;
  1728.   memcpy(Page, &Controller->CurrentStatusBuffer[Offset], Count);
  1729.   return Count;
  1730. }
  1733. /*
  1734.   DAC960_ProcReadUserCommand implements reading /proc/rd/cN/user_command.
  1735. */
  1737. static int DAC960_ProcReadUserCommand(char *Page, char **Start, off_t Offset,
  1738.       int Count, int *EOF, void *Data)
  1739. {
  1740.   DAC960_Controller_T *Controller = (DAC960_Controller_T *) Data;
  1741.   int BytesAvailable = Controller->UserStatusLength - Offset;
  1742.   if (Count >= BytesAvailable)
  1743.     {
  1744.       Count = BytesAvailable;
  1745.       *EOF = true;
  1746.     }
  1747.   if (Count <= 0) return 0;
  1748.   *Start = Page;
  1749.   memcpy(Page, &Controller->UserStatusBuffer[Offset], Count);
  1750.   return Count;
  1751. }
  1754. /*
  1755.   DAC960_ProcWriteUserCommand implements writing /proc/rd/cN/user_command.
  1756. */
  1758. static int DAC960_ProcWriteUserCommand(struct file *file,
  1759.        const char __user *Buffer,
  1760.        unsigned long Count, void *Data)
  1761. {
  1762.   DAC960_Controller_T *Controller = (DAC960_Controller_T *) Data;
  1763.   unsigned char CommandBuffer[80];
  1764.   int Length;
  1765.   if (Count > sizeof(CommandBuffer)-1) return -EINVAL;
  1766.   if (copy_from_user(CommandBuffer, Buffer, Count)) return -EFAULT;
  1767.   CommandBuffer[Count] = '';
  1768.   Length = strlen(CommandBuffer);
  1769.   if (CommandBuffer[Length-1] == 'n')
  1770.     CommandBuffer[--Length] = '';
  1771.   if (Controller->FirmwareType == DAC960_V1_Controller)
  1772.     return (DAC960_V1_ExecuteUserCommand(Controller, CommandBuffer)
  1773.     ? Count : -EBUSY);
  1774.   else
  1775.     return (DAC960_V2_ExecuteUserCommand(Controller, CommandBuffer)
  1776.     ? Count : -EBUSY);
  1777. }
  1780. /*
  1781.   DAC960_CreateProcEntries creates the /proc/rd/... entries for the
  1782.   DAC960 Driver.
  1783. */
  1785. static void DAC960_CreateProcEntries(DAC960_Controller_T *Controller)
  1786. {
  1787. struct proc_dir_entry *StatusProcEntry;
  1788. struct proc_dir_entry *ControllerProcEntry;
  1789. struct proc_dir_entry *UserCommandProcEntry;
  1791. if (DAC960_ProcDirectoryEntry == NULL) {
  1792.    DAC960_ProcDirectoryEntry = proc_mkdir("rd", NULL);
  1793.    StatusProcEntry = create_proc_read_entry("status", 0,
  1794.    DAC960_ProcDirectoryEntry,
  1795.    DAC960_ProcReadStatus, NULL);
  1796. }
  1798.       sprintf(Controller->ControllerName, "c%d", Controller->ControllerNumber);
  1799.       ControllerProcEntry = proc_mkdir(Controller->ControllerName,
  1800.        DAC960_ProcDirectoryEntry);
  1801.       create_proc_read_entry("initial_status", 0, ControllerProcEntry,
  1802.      DAC960_ProcReadInitialStatus, Controller);
  1803.       create_proc_read_entry("current_status", 0, ControllerProcEntry,
  1804.      DAC960_ProcReadCurrentStatus, Controller);
  1805.       UserCommandProcEntry =
  1806. create_proc_read_entry("user_command", S_IWUSR | S_IRUSR,
  1807.        ControllerProcEntry, DAC960_ProcReadUserCommand,
  1808.        Controller);
  1809.       UserCommandProcEntry->write_proc = DAC960_ProcWriteUserCommand;
  1810.       Controller->ControllerProcEntry = ControllerProcEntry;
  1811. }
  1814. /*
  1815.   DAC960_DestroyProcEntries destroys the /proc/rd/... entries for the
  1816.   DAC960 Driver.
  1817. */
  1819. static void DAC960_DestroyProcEntries(DAC960_Controller_T *Controller)
  1820. {
  1821.       if (Controller->ControllerProcEntry == NULL)
  1822.       return;
  1823.       remove_proc_entry("initial_status", Controller->ControllerProcEntry);
  1824.       remove_proc_entry("current_status", Controller->ControllerProcEntry);
  1825.       remove_proc_entry("user_command", Controller->ControllerProcEntry);
  1826.       remove_proc_entry(Controller->ControllerName, DAC960_ProcDirectoryEntry);
  1827.       Controller->ControllerProcEntry = NULL;
  1828. }
  1830. #ifdef DAC960_GAM_MINOR
  1832. /*
  1833.  * DAC960_gam_ioctl is the ioctl function for performing RAID operations.
  1834. */
  1836. static int DAC960_gam_ioctl(struct inode *inode, struct file *file,
  1837.     unsigned int Request, unsigned long Argument)
  1838. {
  1839.   int ErrorCode = 0;
  1840.   if (!capable(CAP_SYS_ADMIN)) return -EACCES;
  1841.   switch (Request)
  1842.     {
  1843.     case DAC960_IOCTL_GET_CONTROLLER_COUNT:
  1844.       return DAC960_ControllerCount;
  1845.     case DAC960_IOCTL_GET_CONTROLLER_INFO:
  1846.       {
  1847. DAC960_ControllerInfo_T __user *UserSpaceControllerInfo =
  1848.   (DAC960_ControllerInfo_T __user *) Argument;
  1849. DAC960_ControllerInfo_T ControllerInfo;
  1850. DAC960_Controller_T *Controller;
  1851. int ControllerNumber;
  1852. if (UserSpaceControllerInfo == NULL) return -EINVAL;
  1853. ErrorCode = get_user(ControllerNumber,
  1854.      &UserSpaceControllerInfo->ControllerNumber);
  1855. if (ErrorCode != 0) return ErrorCode;
  1856. if (ControllerNumber < 0 ||
  1857.     ControllerNumber > DAC960_ControllerCount - 1)
  1858.   return -ENXIO;
  1859. Controller = DAC960_Controllers[ControllerNumber];
  1860. if (Controller == NULL) return -ENXIO;
  1861. memset(&ControllerInfo, 0, sizeof(DAC960_ControllerInfo_T));
  1862. ControllerInfo.ControllerNumber = ControllerNumber;
  1863. ControllerInfo.FirmwareType = Controller->FirmwareType;
  1864. ControllerInfo.Channels = Controller->Channels;
  1865. ControllerInfo.Targets = Controller->Targets;
  1866. ControllerInfo.PCI_Bus = Controller->Bus;
  1867. ControllerInfo.PCI_Device = Controller->Device;
  1868. ControllerInfo.PCI_Function = Controller->Function;
  1869. ControllerInfo.IRQ_Channel = Controller->IRQ_Channel;
  1870. ControllerInfo.PCI_Address = Controller->PCI_Address;
  1871. strcpy(ControllerInfo.ModelName, Controller->ModelName);
  1872. strcpy(ControllerInfo.FirmwareVersion, Controller->FirmwareVersion);
  1873. return (copy_to_user(UserSpaceControllerInfo, &ControllerInfo,
  1874.      sizeof(DAC960_ControllerInfo_T)) ? -EFAULT : 0);
  1875.       }
  1876.     case DAC960_IOCTL_V1_EXECUTE_COMMAND:
  1877.       {
  1878. DAC960_V1_UserCommand_T __user *UserSpaceUserCommand =
  1879.   (DAC960_V1_UserCommand_T __user *) Argument;
  1880. DAC960_V1_UserCommand_T UserCommand;
  1881. DAC960_Controller_T *Controller;
  1882. DAC960_Command_T *Command = NULL;
  1883. DAC960_V1_CommandOpcode_T CommandOpcode;
  1884. DAC960_V1_CommandStatus_T CommandStatus;
  1885. DAC960_V1_DCDB_T DCDB;
  1886. DAC960_V1_DCDB_T *DCDB_IOBUF = NULL;
  1887. dma_addr_t DCDB_IOBUFDMA;
  1888. unsigned long flags;
  1889. int ControllerNumber, DataTransferLength;
  1890. unsigned char *DataTransferBuffer = NULL;
  1891. dma_addr_t DataTransferBufferDMA;
  1892. if (UserSpaceUserCommand == NULL) return -EINVAL;
  1893. if (copy_from_user(&UserCommand, UserSpaceUserCommand,
  1894.    sizeof(DAC960_V1_UserCommand_T))) {
  1895. ErrorCode = -EFAULT;
  1896. goto Failure1a;
  1897. }
  1898. ControllerNumber = UserCommand.ControllerNumber;
  1899. if (ControllerNumber < 0 ||
  1900.     ControllerNumber > DAC960_ControllerCount - 1)
  1901.   return -ENXIO;
  1902. Controller = DAC960_Controllers[ControllerNumber];
  1903. if (Controller == NULL) return -ENXIO;
  1904. if (Controller->FirmwareType != DAC960_V1_Controller) return -EINVAL;
  1905. CommandOpcode = UserCommand.CommandMailbox.Common.CommandOpcode;
  1906. DataTransferLength = UserCommand.DataTransferLength;
  1907. if (CommandOpcode & 0x80) return -EINVAL;
  1908. if (CommandOpcode == DAC960_V1_DCDB)
  1909.   {
  1910.     if (copy_from_user(&DCDB, UserCommand.DCDB,
  1911.        sizeof(DAC960_V1_DCDB_T))) {
  1912. ErrorCode = -EFAULT;
  1913. goto Failure1a;
  1914.     }
  1915.     if (DCDB.Channel >= DAC960_V1_MaxChannels) return -EINVAL;
  1916.     if (!((DataTransferLength == 0 &&
  1917.    DCDB.Direction
  1918.    == DAC960_V1_DCDB_NoDataTransfer) ||
  1919.   (DataTransferLength > 0 &&
  1920.    DCDB.Direction
  1921.    == DAC960_V1_DCDB_DataTransferDeviceToSystem) ||
  1922.   (DataTransferLength < 0 &&
  1923.    DCDB.Direction
  1924.    == DAC960_V1_DCDB_DataTransferSystemToDevice)))
  1925.       return -EINVAL;
  1926.     if (((DCDB.TransferLengthHigh4 << 16) | DCDB.TransferLength)
  1927. != abs(DataTransferLength))
  1928.       return -EINVAL;
  1929.     DCDB_IOBUF = pci_alloc_consistent(Controller->PCIDevice,
  1930. sizeof(DAC960_V1_DCDB_T), &DCDB_IOBUFDMA);
  1931.     if (DCDB_IOBUF == NULL)
  1932. return -ENOMEM;
  1933.   }
  1934. if (DataTransferLength > 0)
  1935.   {
  1936.     DataTransferBuffer = pci_alloc_consistent(Controller->PCIDevice,
  1937. DataTransferLength, &DataTransferBufferDMA);
  1938.     if (DataTransferBuffer == NULL) {
  1939. ErrorCode = -ENOMEM;
  1940. goto Failure1;
  1941.     }
  1942.     memset(DataTransferBuffer, 0, DataTransferLength);
  1943.   }
  1944. else if (DataTransferLength < 0)
  1945.   {
  1946.     DataTransferBuffer = pci_alloc_consistent(Controller->PCIDevice,
  1947. -DataTransferLength, &DataTransferBufferDMA);
  1948.     if (DataTransferBuffer == NULL) {
  1949. ErrorCode = -ENOMEM;
  1950. goto Failure1;
  1951.     }
  1952.     if (copy_from_user(DataTransferBuffer,
  1953.        UserCommand.DataTransferBuffer,
  1954.        -DataTransferLength)) {
  1955. ErrorCode = -EFAULT;
  1956. goto Failure1;
  1957.     }
  1958.   }
  1959. if (CommandOpcode == DAC960_V1_DCDB)
  1960.   {
  1961.     spin_lock_irqsave(&Controller->queue_lock, flags);
  1962.     while ((Command = DAC960_AllocateCommand(Controller)) == NULL)
  1963.       DAC960_WaitForCommand(Controller);
  1964.     while (Controller->V1.DirectCommandActive[DCDB.Channel]
  1965.      [DCDB.TargetID])
  1966.       {
  1967. spin_unlock_irq(&Controller->queue_lock);
  1968. __wait_event(Controller->CommandWaitQueue,
  1969.      !Controller->V1.DirectCommandActive
  1970.      [DCDB.Channel][DCDB.TargetID]);
  1971. spin_lock_irq(&Controller->queue_lock);
  1972.       }
  1973.     Controller->V1.DirectCommandActive[DCDB.Channel]
  1974.       [DCDB.TargetID] = true;
  1975.     spin_unlock_irqrestore(&Controller->queue_lock, flags);
  1976.     DAC960_V1_ClearCommand(Command);
  1977.     Command->CommandType = DAC960_ImmediateCommand;
  1978.     memcpy(&Command->V1.CommandMailbox, &UserCommand.CommandMailbox,
  1979.    sizeof(DAC960_V1_CommandMailbox_T));
  1980.     Command->V1.CommandMailbox.Type3.BusAddress = DCDB_IOBUFDMA;
  1981.     DCDB.BusAddress = DataTransferBufferDMA;
  1982.     memcpy(DCDB_IOBUF, &DCDB, sizeof(DAC960_V1_DCDB_T));
  1983.   }
  1984. else
  1985.   {
  1986.     spin_lock_irqsave(&Controller->queue_lock, flags);
  1987.     while ((Command = DAC960_AllocateCommand(Controller)) == NULL)
  1988.       DAC960_WaitForCommand(Controller);
  1989.     spin_unlock_irqrestore(&Controller->queue_lock, flags);
  1990.     DAC960_V1_ClearCommand(Command);
  1991.     Command->CommandType = DAC960_ImmediateCommand;
  1992.     memcpy(&Command->V1.CommandMailbox, &UserCommand.CommandMailbox,
  1993.    sizeof(DAC960_V1_CommandMailbox_T));
  1994.     if (DataTransferBuffer != NULL)
  1995.       Command->V1.CommandMailbox.Type3.BusAddress =
  1996. DataTransferBufferDMA;
  1997.   }
  1998. DAC960_ExecuteCommand(Command);
  1999. CommandStatus = Command->V1.CommandStatus;
  2000. spin_lock_irqsave(&Controller->queue_lock, flags);
  2001. DAC960_DeallocateCommand(Command);
  2002. spin_unlock_irqrestore(&Controller->queue_lock, flags);
  2003. if (DataTransferLength > 0)
  2004.   {
  2005.     if (copy_to_user(UserCommand.DataTransferBuffer,
  2006.      DataTransferBuffer, DataTransferLength)) {
  2007. ErrorCode = -EFAULT;
  2008. goto Failure1;
  2009.             }
  2010.   }
  2011. if (CommandOpcode == DAC960_V1_DCDB)
  2012.   {
  2013.     /*
  2014.       I don't believe Target or Channel in the DCDB_IOBUF
  2015.       should be any different from the contents of DCDB.
  2016.      */
  2017.     Controller->V1.DirectCommandActive[DCDB.Channel]
  2018.       [DCDB.TargetID] = false;
  2019.     if (copy_to_user(UserCommand.DCDB, DCDB_IOBUF,
  2020.      sizeof(DAC960_V1_DCDB_T))) {
  2021. ErrorCode = -EFAULT;
  2022. goto Failure1;
  2023.     }
  2024.   }
  2025. ErrorCode = CommandStatus;
  2026.       Failure1:
  2027. if (DataTransferBuffer != NULL)
  2028.   pci_free_consistent(Controller->PCIDevice, abs(DataTransferLength),
  2029. DataTransferBuffer, DataTransferBufferDMA);
  2030. if (DCDB_IOBUF != NULL)
  2031.   pci_free_consistent(Controller->PCIDevice, sizeof(DAC960_V1_DCDB_T),
  2032. DCDB_IOBUF, DCDB_IOBUFDMA);
  2033.       Failure1a:
  2034. return ErrorCode;
  2035.       }
  2036.     case DAC960_IOCTL_V2_EXECUTE_COMMAND:
  2037.       {
  2038. DAC960_V2_UserCommand_T __user *UserSpaceUserCommand =
  2039.   (DAC960_V2_UserCommand_T __user *) Argument;
  2040. DAC960_V2_UserCommand_T UserCommand;
  2041. DAC960_Controller_T *Controller;
  2042. DAC960_Command_T *Command = NULL;
  2043. DAC960_V2_CommandMailbox_T *CommandMailbox;
  2044. DAC960_V2_CommandStatus_T CommandStatus;
  2045. unsigned long flags;
  2046. int ControllerNumber, DataTransferLength;
  2047. int DataTransferResidue, RequestSenseLength;
  2048. unsigned char *DataTransferBuffer = NULL;
  2049. dma_addr_t DataTransferBufferDMA;
  2050. unsigned char *RequestSenseBuffer = NULL;
  2051. dma_addr_t RequestSenseBufferDMA;
  2052. if (UserSpaceUserCommand == NULL) return -EINVAL;
  2053. if (copy_from_user(&UserCommand, UserSpaceUserCommand,
  2054.    sizeof(DAC960_V2_UserCommand_T))) {
  2055. ErrorCode = -EFAULT;
  2056. goto Failure2a;
  2057. }
  2058. ControllerNumber = UserCommand.ControllerNumber;
  2059. if (ControllerNumber < 0 ||
  2060.     ControllerNumber > DAC960_ControllerCount - 1)
  2061.   return -ENXIO;
  2062. Controller = DAC960_Controllers[ControllerNumber];
  2063. if (Controller == NULL) return -ENXIO;
  2064. if (Controller->FirmwareType != DAC960_V2_Controller) return -EINVAL;
  2065. DataTransferLength = UserCommand.DataTransferLength;
  2066. if (DataTransferLength > 0)
  2067.   {
  2068.     DataTransferBuffer = pci_alloc_consistent(Controller->PCIDevice,
  2069. DataTransferLength, &DataTransferBufferDMA);
  2070.     if (DataTransferBuffer == NULL) return -ENOMEM;
  2071.     memset(DataTransferBuffer, 0, DataTransferLength);
  2072.   }
  2073. else if (DataTransferLength < 0)
  2074.   {
  2075.     DataTransferBuffer = pci_alloc_consistent(Controller->PCIDevice,
  2076. -DataTransferLength, &DataTransferBufferDMA);
  2077.     if (DataTransferBuffer == NULL) return -ENOMEM;
  2078.     if (copy_from_user(DataTransferBuffer,
  2079.        UserCommand.DataTransferBuffer,
  2080.        -DataTransferLength)) {
  2081. ErrorCode = -EFAULT;
  2082. goto Failure2;
  2083.     }
  2084.   }
  2085. RequestSenseLength = UserCommand.RequestSenseLength;
  2086. if (RequestSenseLength > 0)
  2087.   {
  2088.     RequestSenseBuffer = pci_alloc_consistent(Controller->PCIDevice,
  2089. RequestSenseLength, &RequestSenseBufferDMA);
  2090.     if (RequestSenseBuffer == NULL)
  2091.       {
  2092. ErrorCode = -ENOMEM;
  2093. goto Failure2;
  2094.       }
  2095.     memset(RequestSenseBuffer, 0, RequestSenseLength);
  2096.   }
  2097. spin_lock_irqsave(&Controller->queue_lock, flags);
  2098. while ((Command = DAC960_AllocateCommand(Controller)) == NULL)
  2099.   DAC960_WaitForCommand(Controller);
  2100. spin_unlock_irqrestore(&Controller->queue_lock, flags);
  2101. DAC960_V2_ClearCommand(Command);
  2102. Command->CommandType = DAC960_ImmediateCommand;
  2103. CommandMailbox = &Command->V2.CommandMailbox;
  2104. memcpy(CommandMailbox, &UserCommand.CommandMailbox,
  2105.        sizeof(DAC960_V2_CommandMailbox_T));
  2106. CommandMailbox->Common.CommandControlBits
  2107.       .AdditionalScatterGatherListMemory = false;
  2108. CommandMailbox->Common.CommandControlBits
  2109.       .NoAutoRequestSense = true;
  2110. CommandMailbox->Common.DataTransferSize = 0;
  2111. CommandMailbox->Common.DataTransferPageNumber = 0;
  2112. memset(&CommandMailbox->Common.DataTransferMemoryAddress, 0,
  2113.        sizeof(DAC960_V2_DataTransferMemoryAddress_T));
  2114. if (DataTransferLength != 0)
  2115.   {
  2116.     if (DataTransferLength > 0)
  2117.       {
  2118. CommandMailbox->Common.CommandControlBits
  2119.       .DataTransferControllerToHost = true;
  2120. CommandMailbox->Common.DataTransferSize = DataTransferLength;
  2121.       }
  2122.     else
  2123.       {
  2124. CommandMailbox->Common.CommandControlBits
  2125.       .DataTransferControllerToHost = false;
  2126. CommandMailbox->Common.DataTransferSize = -DataTransferLength;
  2127.       }
  2128.     CommandMailbox->Common.DataTransferMemoryAddress
  2129.   .ScatterGatherSegments[0]
  2130.   .SegmentDataPointer = DataTransferBufferDMA;
  2131.     CommandMailbox->Common.DataTransferMemoryAddress
  2132.   .ScatterGatherSegments[0]
  2133.   .SegmentByteCount =
  2134.       CommandMailbox->Common.DataTransferSize;
  2135.   }
  2136. if (RequestSenseLength > 0)
  2137.   {
  2138.     CommandMailbox->Common.CommandControlBits
  2139.   .NoAutoRequestSense = false;
  2140.     CommandMailbox->Common.RequestSenseSize = RequestSenseLength;
  2141.     CommandMailbox->Common.RequestSenseBusAddress =
  2142.        RequestSenseBufferDMA;
  2143.   }
  2144. DAC960_ExecuteCommand(Command);
  2145. CommandStatus = Command->V2.CommandStatus;
  2146. RequestSenseLength = Command->V2.RequestSenseLength;
  2147. DataTransferResidue = Command->V2.DataTransferResidue;
  2148. spin_lock_irqsave(&Controller->queue_lock, flags);
  2149. DAC960_DeallocateCommand(Command);
  2150. spin_unlock_irqrestore(&Controller->queue_lock, flags);
  2151. if (RequestSenseLength > UserCommand.RequestSenseLength)
  2152.   RequestSenseLength = UserCommand.RequestSenseLength;
  2153. if (copy_to_user(&UserSpaceUserCommand->DataTransferLength,
  2154.  &DataTransferResidue,
  2155.  sizeof(DataTransferResidue))) {
  2156. ErrorCode = -EFAULT;
  2157. goto Failure2;
  2158. }
  2159. if (copy_to_user(&UserSpaceUserCommand->RequestSenseLength,
  2160.  &RequestSenseLength, sizeof(RequestSenseLength))) {
  2161. ErrorCode = -EFAULT;
  2162. goto Failure2;
  2163. }
  2164. if (DataTransferLength > 0)
  2165.   {
  2166.     if (copy_to_user(UserCommand.DataTransferBuffer,
  2167.      DataTransferBuffer, DataTransferLength)) {
  2168. ErrorCode = -EFAULT;
  2169. goto Failure2;
  2170.     }
  2171.   }
  2172. if (RequestSenseLength > 0)
  2173.   {
  2174.     if (copy_to_user(UserCommand.RequestSenseBuffer,
  2175.      RequestSenseBuffer, RequestSenseLength)) {
  2176. ErrorCode = -EFAULT;
  2177. goto Failure2;
  2178.     }
  2179.   }
  2180. ErrorCode = CommandStatus;
  2181.       Failure2:
  2182.   pci_free_consistent(Controller->PCIDevice, abs(DataTransferLength),
  2183. DataTransferBuffer, DataTransferBufferDMA);
  2184. if (RequestSenseBuffer != NULL)
  2185.   pci_free_consistent(Controller->PCIDevice, RequestSenseLength,
  2186. RequestSenseBuffer, RequestSenseBufferDMA);
  2187.       Failure2a:
  2188. return ErrorCode;
  2189.       }
  2190.     case DAC960_IOCTL_V2_GET_HEALTH_STATUS:
  2191.       {
  2192. DAC960_V2_GetHealthStatus_T __user *UserSpaceGetHealthStatus =
  2193.   (DAC960_V2_GetHealthStatus_T __user *) Argument;
  2194. DAC960_V2_GetHealthStatus_T GetHealthStatus;
  2195. DAC960_V2_HealthStatusBuffer_T HealthStatusBuffer;
  2196. DAC960_Controller_T *Controller;
  2197. int ControllerNumber;
  2198. if (UserSpaceGetHealthStatus == NULL) return -EINVAL;
  2199. if (copy_from_user(&GetHealthStatus, UserSpaceGetHealthStatus,
  2200.    sizeof(DAC960_V2_GetHealthStatus_T)))
  2201. return -EFAULT;
  2202. ControllerNumber = GetHealthStatus.ControllerNumber;
  2203. if (ControllerNumber < 0 ||
  2204.     ControllerNumber > DAC960_ControllerCount - 1)
  2205.   return -ENXIO;
  2206. Controller = DAC960_Controllers[ControllerNumber];
  2207. if (Controller == NULL) return -ENXIO;
  2208. if (Controller->FirmwareType != DAC960_V2_Controller) return -EINVAL;
  2209. if (copy_from_user(&HealthStatusBuffer,
  2210.    GetHealthStatus.HealthStatusBuffer,
  2211.    sizeof(DAC960_V2_HealthStatusBuffer_T)))
  2212. return -EFAULT;
  2213. while (Controller->V2.HealthStatusBuffer->StatusChangeCounter
  2214.        == HealthStatusBuffer.StatusChangeCounter &&
  2215.        Controller->V2.HealthStatusBuffer->NextEventSequenceNumber
  2216.        == HealthStatusBuffer.NextEventSequenceNumber)
  2217.   {
  2218.     interruptible_sleep_on_timeout(&Controller->HealthStatusWaitQueue,
  2219.    DAC960_MonitoringTimerInterval);
  2220.     if (signal_pending(current)) return -EINTR;
  2221.   }
  2222. if (copy_to_user(GetHealthStatus.HealthStatusBuffer,
  2223.  Controller->V2.HealthStatusBuffer,
  2224.  sizeof(DAC960_V2_HealthStatusBuffer_T)))
  2225. return -EFAULT;
  2226. return 0;
  2227.       }
  2228.     }
  2229.   return -EINVAL;
  2230. }
  2232. static struct file_operations DAC960_gam_fops = {
  2233. .owner = THIS_MODULE,
  2234. .ioctl = DAC960_gam_ioctl
  2235. };
  2237. static struct miscdevice DAC960_gam_dev = {
  2238. DAC960_GAM_MINOR,
  2239. "dac960_gam",
  2240. &DAC960_gam_fops
  2241. };
  2243. static int DAC960_gam_init(void)
  2244. {
  2245. int ret;
  2247. ret = misc_register(&DAC960_gam_dev);
  2248. if (ret)
  2249. printk(KERN_ERR "DAC960_gam: can't misc_register on minor %dn", DAC960_GAM_MINOR);
  2250. return ret;
  2251. }
  2253. static void DAC960_gam_cleanup(void)
  2254. {
  2255. misc_deregister(&DAC960_gam_dev);
  2256. }
  2258. #endif /* DAC960_GAM_MINOR */
  2260. static struct DAC960_privdata DAC960_GEM_privdata = {
  2261. .HardwareType = DAC960_GEM_Controller,
  2262. .FirmwareType  = DAC960_V2_Controller,
  2263. .InterruptHandler = DAC960_GEM_InterruptHandler,
  2264. .MemoryWindowSize = DAC960_GEM_RegisterWindowSize,
  2265. };
  2268. static struct DAC960_privdata DAC960_BA_privdata = {
  2269. .HardwareType = DAC960_BA_Controller,
  2270. .FirmwareType  = DAC960_V2_Controller,
  2271. .InterruptHandler = DAC960_BA_InterruptHandler,
  2272. .MemoryWindowSize = DAC960_BA_RegisterWindowSize,
  2273. };
  2275. static struct DAC960_privdata DAC960_LP_privdata = {
  2276. .HardwareType = DAC960_LP_Controller,
  2277. .FirmwareType  = DAC960_LP_Controller,
  2278. .InterruptHandler = DAC960_LP_InterruptHandler,
  2279. .MemoryWindowSize = DAC960_LP_RegisterWindowSize,
  2280. };
  2282. static struct DAC960_privdata DAC960_LA_privdata = {
  2283. .HardwareType = DAC960_LA_Controller,
  2284. .FirmwareType  = DAC960_V1_Controller,
  2285. .InterruptHandler = DAC960_LA_InterruptHandler,
  2286. .MemoryWindowSize = DAC960_LA_RegisterWindowSize,
  2287. };
  2289. static struct DAC960_privdata DAC960_PG_privdata = {
  2290. .HardwareType = DAC960_PG_Controller,
  2291. .FirmwareType  = DAC960_V1_Controller,
  2292. .InterruptHandler = DAC960_PG_InterruptHandler,
  2293. .MemoryWindowSize = DAC960_PG_RegisterWindowSize,
  2294. };
  2296. static struct DAC960_privdata DAC960_PD_privdata = {
  2297. .HardwareType = DAC960_PD_Controller,
  2298. .FirmwareType  = DAC960_V1_Controller,
  2299. .InterruptHandler = DAC960_PD_InterruptHandler,
  2300. .MemoryWindowSize = DAC960_PD_RegisterWindowSize,
  2301. };
  2303. static struct DAC960_privdata DAC960_P_privdata = {
  2304. .HardwareType = DAC960_P_Controller,
  2305. .FirmwareType  = DAC960_V1_Controller,
  2306. .InterruptHandler = DAC960_P_InterruptHandler,
  2307. .MemoryWindowSize = DAC960_PD_RegisterWindowSize,
  2308. };
  2310. static struct pci_device_id DAC960_id_table[] = {
  2311. {
  2312. .vendor  = PCI_VENDOR_ID_MYLEX,
  2313. .device = PCI_DEVICE_ID_MYLEX_DAC960_GEM,
  2314. .subvendor = PCI_ANY_ID,
  2315. .subdevice = PCI_ANY_ID,
  2316. .driver_data = (unsigned long) &DAC960_GEM_privdata,
  2317. },
  2318. {
  2319. .vendor  = PCI_VENDOR_ID_MYLEX,
  2320. .device = PCI_DEVICE_ID_MYLEX_DAC960_BA,
  2321. .subvendor = PCI_ANY_ID,
  2322. .subdevice = PCI_ANY_ID,
  2323. .driver_data = (unsigned long) &DAC960_BA_privdata,
  2324. },
  2325. {
  2326. .vendor  = PCI_VENDOR_ID_MYLEX,
  2327. .device = PCI_DEVICE_ID_MYLEX_DAC960_LP,
  2328. .subvendor = PCI_ANY_ID,
  2329. .subdevice = PCI_ANY_ID,
  2330. .driver_data = (unsigned long) &DAC960_LP_privdata,
  2331. },
  2332. {
  2333. .vendor  = PCI_VENDOR_ID_DEC,
  2334. .device = PCI_DEVICE_ID_DEC_21285,
  2335. .subvendor = PCI_VENDOR_ID_MYLEX,
  2336. .subdevice = PCI_DEVICE_ID_MYLEX_DAC960_LA,
  2337. .driver_data = (unsigned long) &DAC960_LA_privdata,
  2338. },
  2339. {
  2340. .vendor  = PCI_VENDOR_ID_MYLEX,
  2341. .device = PCI_DEVICE_ID_MYLEX_DAC960_PG,
  2342. .subvendor = PCI_ANY_ID,
  2343. .subdevice = PCI_ANY_ID,
  2344. .driver_data = (unsigned long) &DAC960_PG_privdata,
  2345. },
  2346. {
  2347. .vendor  = PCI_VENDOR_ID_MYLEX,
  2348. .device = PCI_DEVICE_ID_MYLEX_DAC960_PD,
  2349. .subvendor = PCI_ANY_ID,
  2350. .subdevice = PCI_ANY_ID,
  2351. .driver_data = (unsigned long) &DAC960_PD_privdata,
  2352. },
  2353. {
  2354. .vendor  = PCI_VENDOR_ID_MYLEX,
  2355. .device = PCI_DEVICE_ID_MYLEX_DAC960_P,
  2356. .subvendor = PCI_ANY_ID,
  2357. .subdevice = PCI_ANY_ID,
  2358. .driver_data = (unsigned long) &DAC960_P_privdata,
  2359. },
  2360. {0, },
  2361. };
  2363. MODULE_DEVICE_TABLE(pci, DAC960_id_table);
  2365. static struct pci_driver DAC960_pci_driver = {
  2366. .name = "DAC960",
  2367. .id_table = DAC960_id_table,
  2368. .probe = DAC960_Probe,
  2369. .remove = DAC960_Remove,
  2370. };
  2372. static int DAC960_init_module(void)
  2373. {
  2374. int ret;
  2376. ret =  pci_module_init(&DAC960_pci_driver);
  2377. #ifdef DAC960_GAM_MINOR
  2378. if (!ret)
  2379. DAC960_gam_init();
  2380. #endif
  2381. return ret;
  2382. }
  2384. static void DAC960_cleanup_module(void)
  2385. {
  2386. int i;
  2388. #ifdef DAC960_GAM_MINOR
  2389. DAC960_gam_cleanup();
  2390. #endif
  2392. for (i = 0; i < DAC960_ControllerCount; i++) {
  2393. DAC960_Controller_T *Controller = DAC960_Controllers[i];
  2394. if (Controller == NULL)
  2395. continue;
  2396. DAC960_FinalizeController(Controller);
  2397. }
  2398. if (DAC960_ProcDirectoryEntry != NULL) {
  2399.    remove_proc_entry("rd/status", NULL);
  2400.    remove_proc_entry("rd", NULL);
  2401. }
  2402. DAC960_ControllerCount = 0;
  2403. pci_unregister_driver(&DAC960_pci_driver);
  2404. }
  2406. module_init(DAC960_init_module);
  2407. module_exit(DAC960_cleanup_module);
  2409. MODULE_LICENSE("GPL");