it as a module, say M here and read Documentation/modules.txt. The
module will be called
+IrDA protocol options
+CONFIG_IRDA_OPTIONS
+ Say Y here if you want to configure any of the following IrDA options.
+
IrDA Cache last LSAP
CONFIG_IRDA_CACHE_LAST_LSAP
Say Y here if you want IrLMP to cache the last LSAP used. This makes
Linux Driver for Mylex DAC960/AcceleRAID/eXtremeRAID PCI RAID Controllers
- Version 2.2.9 for Linux 2.2.17
- Version 2.4.9 for Linux 2.4.0
+ Version 2.2.10 for Linux 2.2.18
+ Version 2.4.10 for Linux 2.4.1
PRODUCTION RELEASE
- 7 September 2000
+ 1 February 2001
Leonard N. Zubkoff
Dandelion Digital
lnz@dandelion.com
- Copyright 1998-2000 by Leonard N. Zubkoff <lnz@dandelion.com>
+ Copyright 1998-2001 by Leonard N. Zubkoff <lnz@dandelion.com>
INTRODUCTION
properly initializes the AcceleRAID 250, AcceleRAID 200, AcceleRAID 150,
DAC960PJ, and DAC960PG because the Intel i960RD/RP is a multi-function device.
If in doubt, contact Mylex RAID Technical Support (support@mylex.com) to verify
-compatibility. Mylex makes available a hard disk compatibility list by FTP at
-ftp://ftp.mylex.com/pub/dac960/diskcomp.html.
+compatibility. Mylex makes available a hard disk compatibility list at
+http://www.mylex.com/support/hdcomp/hd-lists.html.
DRIVER INSTALLATION
-This distribution was prepared for Linux kernel version 2.2.17 or 2.4.0.
+This distribution was prepared for Linux kernel version 2.2.18 or 2.4.1.
To install the DAC960 RAID driver, you may use the following commands,
replacing "/usr/src" with wherever you keep your Linux kernel source tree:
cd /usr/src
- tar -xvzf DAC960-2.2.9.tar.gz (or DAC960-2.4.9.tar.gz)
+ tar -xvzf DAC960-2.2.10.tar.gz (or DAC960-2.4.10.tar.gz)
mv README.DAC960 linux/Documentation
mv DAC960.[ch] linux/drivers/block
patch -p0 < DAC960.patch (if DAC960.patch is included)
stq $26,0($30)
stq $19,8($30)
.prologue 1
+#ifdef __SMP__
+ jsr $26,___kernel_execve
+#else
jsr $26,do_execve
+#endif /* __SMP__ */
bne $0,1f /* error! */
ldq $30,8($30)
br $31,ret_from_sys_call
isync /* Handle erratas in some cases */
blr
+_GLOBAL(_get_ICTC)
+ mfspr r3,ICTC
+ blr
+
+_GLOBAL(_set_ICTC)
+ mtspr ICTC,r3
+ blr
+
/*
L2CR functions
Copyright © 1997-1998 by PowerLogix R & D, Inc.
Linux Driver for Mylex DAC960/AcceleRAID/eXtremeRAID PCI RAID Controllers
- Copyright 1998-2000 by Leonard N. Zubkoff <lnz@dandelion.com>
+ Copyright 1998-2001 by Leonard N. Zubkoff <lnz@dandelion.com>
This program is free software; you may redistribute and/or modify it under
the terms of the GNU General Public License Version 2 as published by the
*/
-#define DAC960_DriverVersion "2.2.9"
-#define DAC960_DriverDate "7 September 2000"
+#define DAC960_DriverVersion "2.2.10"
+#define DAC960_DriverDate "1 February 2001"
#include <linux/version.h>
DAC960_Announce("***** DAC960 RAID Driver Version "
DAC960_DriverVersion " of "
DAC960_DriverDate " *****\n", Controller);
- DAC960_Announce("Copyright 1998-2000 by Leonard N. Zubkoff "
+ DAC960_Announce("Copyright 1998-2001 by Leonard N. Zubkoff "
"<lnz@dandelion.com>\n", Controller);
}
DAC960_V1_ClearCommand(Command);
Command->CommandType = DAC960_ImmediateCommand;
CommandMailbox->Type3.CommandOpcode = CommandOpcode;
- CommandMailbox->Type3.BusAddress = Virtual_to_Bus(DataPointer);
+ CommandMailbox->Type3.BusAddress = Virtual_to_Bus32(DataPointer);
DAC960_ExecuteCommand(Command);
CommandStatus = Command->V1.CommandStatus;
DAC960_DeallocateCommand(Command);
CommandMailbox->Type3D.CommandOpcode = CommandOpcode;
CommandMailbox->Type3D.Channel = Channel;
CommandMailbox->Type3D.TargetID = TargetID;
- CommandMailbox->Type3D.BusAddress = Virtual_to_Bus(DataPointer);
+ CommandMailbox->Type3D.BusAddress = Virtual_to_Bus32(DataPointer);
DAC960_ExecuteCommand(Command);
CommandStatus = Command->V1.CommandStatus;
DAC960_DeallocateCommand(Command);
CommandMailbox->Common.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(DataPointer);
+ Virtual_to_Bus64(DataPointer);
CommandMailbox->Common.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
CommandMailbox->ControllerInfo.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(DataPointer);
+ Virtual_to_Bus64(DataPointer);
CommandMailbox->ControllerInfo.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
CommandMailbox->LogicalDeviceInfo.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(DataPointer);
+ Virtual_to_Bus64(DataPointer);
CommandMailbox->LogicalDeviceInfo.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
CommandMailbox->PhysicalDeviceInfo.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(DataPointer);
+ Virtual_to_Bus64(DataPointer);
CommandMailbox->PhysicalDeviceInfo.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
CommandMailbox.TypeX.CommandIdentifier = 0;
CommandMailbox.TypeX.CommandOpcode2 = 0x14;
CommandMailbox.TypeX.CommandMailboxesBusAddress =
- Virtual_to_Bus(Controller->V1.FirstCommandMailbox);
+ Virtual_to_Bus32(Controller->V1.FirstCommandMailbox);
CommandMailbox.TypeX.StatusMailboxesBusAddress =
- Virtual_to_Bus(Controller->V1.FirstStatusMailbox);
+ Virtual_to_Bus32(Controller->V1.FirstStatusMailbox);
for (i = 0; i < 2; i++)
switch (Controller->HardwareType)
{
CommandMailbox.SetMemoryMailbox.IOCTL_Opcode = DAC960_V2_SetMemoryMailbox;
CommandMailbox.SetMemoryMailbox.HealthStatusBufferSizeKB = 1;
CommandMailbox.SetMemoryMailbox.HealthStatusBufferBusAddress =
- Virtual_to_Bus(Controller->V2.HealthStatusBuffer);
+ Virtual_to_Bus64(Controller->V2.HealthStatusBuffer);
CommandMailbox.SetMemoryMailbox.FirstCommandMailboxBusAddress =
- Virtual_to_Bus(Controller->V2.FirstCommandMailbox);
+ Virtual_to_Bus64(Controller->V2.FirstCommandMailbox);
CommandMailbox.SetMemoryMailbox.FirstStatusMailboxBusAddress =
- Virtual_to_Bus(Controller->V2.FirstStatusMailbox);
+ Virtual_to_Bus64(Controller->V2.FirstStatusMailbox);
switch (Controller->HardwareType)
{
case DAC960_BA_Controller:
Command->CommandType = DAC960_ImmediateCommand;
Command->Semaphore = Semaphore;
Command->V1.CommandMailbox.Type3.CommandOpcode = DAC960_V1_DCDB;
- Command->V1.CommandMailbox.Type3.BusAddress = Virtual_to_Bus(DCDB);
+ Command->V1.CommandMailbox.Type3.BusAddress = Virtual_to_Bus32(DCDB);
DCDB->Channel = Channel;
DCDB->TargetID = TargetID;
DCDB->Direction = DAC960_V1_DCDB_DataTransferDeviceToSystem;
DCDB->NoAutomaticRequestSense = false;
DCDB->DisconnectPermitted = true;
DCDB->TransferLength = sizeof(DAC960_SCSI_Inquiry_T);
- DCDB->BusAddress = Virtual_to_Bus(InquiryStandardData);
+ DCDB->BusAddress = Virtual_to_Bus32(InquiryStandardData);
DCDB->CDBLength = 6;
DCDB->TransferLengthHigh4 = 0;
DCDB->SenseLength = sizeof(DCDB->SenseData);
Command->Semaphore = Semaphore;
DCDB = &DCDBs[Channel];
DCDB->TransferLength = sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T);
- DCDB->BusAddress = Virtual_to_Bus(InquiryUnitSerialNumber);
+ DCDB->BusAddress = Virtual_to_Bus32(InquiryUnitSerialNumber);
DCDB->SenseLength = sizeof(DCDB->SenseData);
DCDB->CDB[0] = 0x12; /* INQUIRY */
DCDB->CDB[1] = 1; /* EVPD = 1 */
CommandMailbox->SCSI_10.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(InquiryUnitSerialNumber);
+ Virtual_to_Bus64(InquiryUnitSerialNumber);
CommandMailbox->SCSI_10.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
CommandMailbox->Type5.LD.TransferLength = Command->BlockCount;
CommandMailbox->Type5.LD.LogicalDriveNumber = Command->LogicalDriveNumber;
CommandMailbox->Type5.LogicalBlockAddress = Command->BlockNumber;
- CommandMailbox->Type5.BusAddress = Virtual_to_Bus(Command->RequestBuffer);
+ CommandMailbox->Type5.BusAddress =
+ Virtual_to_Bus32(Command->RequestBuffer);
}
else
{
CommandMailbox->Type5.LD.TransferLength = Command->BlockCount;
CommandMailbox->Type5.LD.LogicalDriveNumber = Command->LogicalDriveNumber;
CommandMailbox->Type5.LogicalBlockAddress = Command->BlockNumber;
- CommandMailbox->Type5.BusAddress = Virtual_to_Bus(ScatterGatherList);
+ CommandMailbox->Type5.BusAddress = Virtual_to_Bus32(ScatterGatherList);
CommandMailbox->Type5.ScatterGatherCount = Command->SegmentCount;
while (BufferHeader != NULL)
{
else
{
ScatterGatherList[SegmentNumber].SegmentDataPointer =
- Virtual_to_Bus(BufferHeader->b_data);
+ Virtual_to_Bus32(BufferHeader->b_data);
ScatterGatherList[SegmentNumber].SegmentByteCount =
BufferHeader->b_size;
LastDataEndPointer = BufferHeader->b_data + BufferHeader->b_size;
CommandMailbox->SCSI_10.DataTransferSize =
Command->BlockCount << DAC960_BlockSizeBits;
CommandMailbox->SCSI_10.RequestSenseBusAddress =
- Virtual_to_Bus(&Command->V2.RequestSense);
+ Virtual_to_Bus64(&Command->V2.RequestSense);
CommandMailbox->SCSI_10.PhysicalDevice =
Controller->V2.LogicalDriveToVirtualDevice[Command->LogicalDriveNumber];
CommandMailbox->SCSI_10.RequestSenseSize =
CommandMailbox->SCSI_10.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(Command->RequestBuffer);
+ Virtual_to_Bus64(Command->RequestBuffer);
CommandMailbox->SCSI_10.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
Command->SegmentCount;
CommandMailbox->SCSI_10.DataTransferMemoryAddress
.ExtendedScatterGather.ScatterGatherList0Address =
- Virtual_to_Bus(ScatterGatherList);
+ Virtual_to_Bus64(ScatterGatherList);
}
else
ScatterGatherList =
else
{
ScatterGatherList[SegmentNumber].SegmentDataPointer =
- Virtual_to_Bus(BufferHeader->b_data);
+ Virtual_to_Bus64(BufferHeader->b_data);
ScatterGatherList[SegmentNumber].SegmentByteCount =
BufferHeader->b_size;
LastDataEndPointer = BufferHeader->b_data + BufferHeader->b_size;
Command->BlockCount = BufferHeader->b_size >> DAC960_BlockSizeBits;
CommandMailbox->Type5.LD.TransferLength = Command->BlockCount;
CommandMailbox->Type5.BusAddress =
- Virtual_to_Bus(BufferHeader->b_data);
+ Virtual_to_Bus32(BufferHeader->b_data);
DAC960_QueueCommand(Command);
return;
}
CommandMailbox->Type5.LD.TransferLength = Command->BlockCount;
CommandMailbox->Type5.LogicalBlockAddress = Command->BlockNumber;
CommandMailbox->Type5.BusAddress =
- Virtual_to_Bus(NextBufferHeader->b_data);
+ Virtual_to_Bus32(NextBufferHeader->b_data);
DAC960_QueueCommand(Command);
return;
}
{
if (CommandOpcode == DAC960_V1_Enquiry)
memcpy(&Controller->V1.NewEnquiry,
- Bus_to_Virtual(Command->V1.CommandMailbox.Type3.BusAddress),
+ Bus32_to_Virtual(Command->V1.CommandMailbox
+ .Type3.BusAddress),
sizeof(DAC960_V1_Enquiry_T));
else if (CommandOpcode == DAC960_V1_GetRebuildProgress)
memcpy(&Controller->V1.RebuildProgress,
- Bus_to_Virtual(Command->V1.CommandMailbox.Type3.BusAddress),
+ Bus32_to_Virtual(Command->V1.CommandMailbox
+ .Type3.BusAddress),
sizeof(DAC960_V1_RebuildProgress_T));
}
if (CommandOpcode == DAC960_V1_Enquiry &&
NewEnquiry->CriticalLogicalDriveCount;
if (NewEnquiry->NumberOfLogicalDrives > Controller->LogicalDriveCount)
{
- int LogicalDriveNumber = Controller->LogicalDriveCount;
- while (LogicalDriveNumber < NewEnquiry->NumberOfLogicalDrives)
- {
- DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
- "Now Exists\n", Controller,
- LogicalDriveNumber,
- Controller->ControllerNumber,
- LogicalDriveNumber);
- LogicalDriveNumber++;
- }
- Controller->LogicalDriveCount = LogicalDriveNumber;
+ int LogicalDriveNumber = Controller->LogicalDriveCount - 1;
+ while (++LogicalDriveNumber < NewEnquiry->NumberOfLogicalDrives)
+ DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
+ "Now Exists\n", Controller,
+ LogicalDriveNumber,
+ Controller->ControllerNumber,
+ LogicalDriveNumber);
+ }
+ if (NewEnquiry->NumberOfLogicalDrives < Controller->LogicalDriveCount)
+ {
+ int LogicalDriveNumber = NewEnquiry->NumberOfLogicalDrives - 1;
+ while (++LogicalDriveNumber < Controller->LogicalDriveCount)
+ DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
+ "No Longer Exists\n", Controller,
+ LogicalDriveNumber,
+ Controller->ControllerNumber,
+ LogicalDriveNumber);
}
+ Controller->LogicalDriveCount = NewEnquiry->NumberOfLogicalDrives;
if (NewEnquiry->StatusFlags.DeferredWriteError !=
OldEnquiry->StatusFlags.DeferredWriteError)
DAC960_Critical("Deferred Write Error Flag is now %s\n", Controller,
NewEnquiry->EventLogSequenceNumber;
Controller->V1.NeedErrorTableInformation = true;
Controller->V1.NeedDeviceStateInformation = true;
- Controller->V1.DeviceStateChannel = 0;
- Controller->V1.DeviceStateTargetID = -1;
+ Controller->V1.StartDeviceStateScan = true;
Controller->SecondaryMonitoringTime = jiffies;
}
if (NewEnquiry->RebuildFlag == DAC960_V1_StandbyRebuildInProgress ||
Controller->V1.RebuildFlagPending)
{
DAC960_V1_Enquiry_T *Enquiry = (DAC960_V1_Enquiry_T *)
- Bus_to_Virtual(Command->V1.CommandMailbox.Type3.BusAddress);
+ Bus32_to_Virtual(Command->V1.CommandMailbox.Type3.BusAddress);
Enquiry->RebuildFlag = Controller->V1.PendingRebuildFlag;
Controller->V1.RebuildFlagPending = false;
}
{
Controller->V1.NeedDeviceInquiryInformation = true;
Controller->V1.NeedDeviceSerialNumberInformation = true;
+ Controller->V1.DeviceResetCount
+ [Controller->V1.DeviceStateChannel]
+ [Controller->V1.DeviceStateTargetID] = 0;
}
memcpy(OldDeviceState, NewDeviceState,
sizeof(DAC960_V1_DeviceState_T));
Command->V1.CommandMailbox.Type3E.SequenceNumber =
Controller->V1.OldEventLogSequenceNumber;
Command->V1.CommandMailbox.Type3E.BusAddress =
- Virtual_to_Bus(&Controller->V1.EventLogEntry);
+ Virtual_to_Bus32(&Controller->V1.EventLogEntry);
DAC960_QueueCommand(Command);
return;
}
Command->V1.CommandMailbox.Type3.CommandOpcode =
DAC960_V1_GetErrorTable;
Command->V1.CommandMailbox.Type3.BusAddress =
- Virtual_to_Bus(&Controller->V1.NewErrorTable);
+ Virtual_to_Bus32(&Controller->V1.NewErrorTable);
DAC960_QueueCommand(Command);
return;
}
Command->V1.CommandMailbox.Type3.CommandOpcode =
DAC960_V1_GetRebuildProgress;
Command->V1.CommandMailbox.Type3.BusAddress =
- Virtual_to_Bus(&Controller->V1.RebuildProgress);
+ Virtual_to_Bus32(&Controller->V1.RebuildProgress);
DAC960_QueueCommand(Command);
return;
}
InquiryStandardData->PeripheralDeviceType = 0x1F;
Command->V1.CommandMailbox.Type3.CommandOpcode = DAC960_V1_DCDB;
Command->V1.CommandMailbox.Type3.BusAddress =
- Virtual_to_Bus(DCDB);
+ Virtual_to_Bus32(DCDB);
DCDB->Channel = Controller->V1.DeviceStateChannel;
DCDB->TargetID = Controller->V1.DeviceStateTargetID;
DCDB->Direction = DAC960_V1_DCDB_DataTransferDeviceToSystem;
DCDB->NoAutomaticRequestSense = false;
DCDB->DisconnectPermitted = true;
DCDB->TransferLength = sizeof(DAC960_SCSI_Inquiry_T);
- DCDB->BusAddress = Virtual_to_Bus(InquiryStandardData);
+ DCDB->BusAddress = Virtual_to_Bus32(InquiryStandardData);
DCDB->CDBLength = 6;
DCDB->TransferLengthHigh4 = 0;
DCDB->SenseLength = sizeof(DCDB->SenseData);
InquiryUnitSerialNumber->PeripheralDeviceType = 0x1F;
Command->V1.CommandMailbox.Type3.CommandOpcode = DAC960_V1_DCDB;
Command->V1.CommandMailbox.Type3.BusAddress =
- Virtual_to_Bus(DCDB);
+ Virtual_to_Bus32(DCDB);
DCDB->Channel = Controller->V1.DeviceStateChannel;
DCDB->TargetID = Controller->V1.DeviceStateTargetID;
DCDB->Direction = DAC960_V1_DCDB_DataTransferDeviceToSystem;
DCDB->DisconnectPermitted = true;
DCDB->TransferLength =
sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T);
- DCDB->BusAddress = Virtual_to_Bus(InquiryUnitSerialNumber);
+ DCDB->BusAddress = Virtual_to_Bus32(InquiryUnitSerialNumber);
DCDB->CDBLength = 6;
DCDB->TransferLengthHigh4 = 0;
DCDB->SenseLength = sizeof(DCDB->SenseData);
Controller->V1.NeedDeviceSerialNumberInformation = false;
return;
}
- if (++Controller->V1.DeviceStateTargetID == Controller->Targets)
+ if (Controller->V1.StartDeviceStateScan)
+ {
+ Controller->V1.DeviceStateChannel = 0;
+ Controller->V1.DeviceStateTargetID = 0;
+ Controller->V1.StartDeviceStateScan = false;
+ }
+ else if (++Controller->V1.DeviceStateTargetID == Controller->Targets)
{
Controller->V1.DeviceStateChannel++;
Controller->V1.DeviceStateTargetID = 0;
}
- while (Controller->V1.DeviceStateChannel < Controller->Channels)
+ if (Controller->V1.DeviceStateChannel < Controller->Channels)
{
- DAC960_V1_DeviceState_T *OldDeviceState =
- &Controller->V1.DeviceState[Controller->V1.DeviceStateChannel]
- [Controller->V1.DeviceStateTargetID];
- if (OldDeviceState->Present &&
- OldDeviceState->DeviceType == DAC960_V1_DiskType)
- {
- Command->V1.CommandMailbox.Type3D.CommandOpcode =
- DAC960_V1_GetDeviceState;
- Command->V1.CommandMailbox.Type3D.Channel =
- Controller->V1.DeviceStateChannel;
- Command->V1.CommandMailbox.Type3D.TargetID =
- Controller->V1.DeviceStateTargetID;
- Command->V1.CommandMailbox.Type3D.BusAddress =
- Virtual_to_Bus(&Controller->V1.NewDeviceState);
- DAC960_QueueCommand(Command);
- return;
- }
- if (++Controller->V1.DeviceStateTargetID == Controller->Targets)
- {
- Controller->V1.DeviceStateChannel++;
- Controller->V1.DeviceStateTargetID = 0;
- }
+ Controller->V1.NewDeviceState.DeviceState =
+ DAC960_V1_Device_Dead;
+ Command->V1.CommandMailbox.Type3D.CommandOpcode =
+ DAC960_V1_GetDeviceState;
+ Command->V1.CommandMailbox.Type3D.Channel =
+ Controller->V1.DeviceStateChannel;
+ Command->V1.CommandMailbox.Type3D.TargetID =
+ Controller->V1.DeviceStateTargetID;
+ Command->V1.CommandMailbox.Type3D.BusAddress =
+ Virtual_to_Bus32(&Controller->V1.NewDeviceState);
+ DAC960_QueueCommand(Command);
+ return;
}
Controller->V1.NeedDeviceStateInformation = false;
}
Command->V1.CommandMailbox.Type3.CommandOpcode =
DAC960_V1_GetLogicalDriveInformation;
Command->V1.CommandMailbox.Type3.BusAddress =
- Virtual_to_Bus(&Controller->V1.NewLogicalDriveInformation);
+ Virtual_to_Bus32(&Controller->V1.NewLogicalDriveInformation);
DAC960_QueueCommand(Command);
return;
}
Command->V1.CommandMailbox.Type3.CommandOpcode =
DAC960_V1_GetRebuildProgress;
Command->V1.CommandMailbox.Type3.BusAddress =
- Virtual_to_Bus(&Controller->V1.RebuildProgress);
+ Virtual_to_Bus32(&Controller->V1.RebuildProgress);
DAC960_QueueCommand(Command);
return;
}
Command->V1.CommandMailbox.Type3.CommandOpcode =
DAC960_V1_RebuildStat;
Command->V1.CommandMailbox.Type3.BusAddress =
- Virtual_to_Bus(&Controller->V1.RebuildProgress);
+ Virtual_to_Bus32(&Controller->V1.RebuildProgress);
DAC960_QueueCommand(Command);
return;
}
Command->BlockCount << DAC960_BlockSizeBits;
CommandMailbox->SCSI_10.DataTransferMemoryAddress
.ScatterGatherSegments[0].SegmentDataPointer =
- Virtual_to_Bus(BufferHeader->b_data);
+ Virtual_to_Bus64(BufferHeader->b_data);
CommandMailbox->SCSI_10.DataTransferMemoryAddress
.ScatterGatherSegments[0].SegmentByteCount =
CommandMailbox->SCSI_10.DataTransferSize;
CommandMailbox->SCSI_10.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(NextBufferHeader->b_data);
+ Virtual_to_Bus64(NextBufferHeader->b_data);
CommandMailbox->SCSI_10.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
Controller->LogicalDriveCount =
NewControllerInfo->LogicalDevicesPresent;
Controller->V2.NeedLogicalDeviceInformation = true;
- Controller->V2.NewLogicalDeviceInformation.LogicalDeviceNumber = 0;
Controller->V2.NeedPhysicalDeviceInformation = true;
- Controller->V2.PhysicalDeviceIndex = 0;
- Controller->V2.NewPhysicalDeviceInformation.Channel = 0;
- Controller->V2.NewPhysicalDeviceInformation.TargetID = 0;
- Controller->V2.NewPhysicalDeviceInformation.LogicalUnit = 0;
+ Controller->V2.StartLogicalDeviceInformationScan = true;
+ Controller->V2.StartPhysicalDeviceInformationScan = true;
Controller->MonitoringAlertMode =
(NewControllerInfo->LogicalDevicesCritical > 0 ||
NewControllerInfo->LogicalDevicesOffline > 0 ||
unsigned int PhysicalDeviceIndex = Controller->V2.PhysicalDeviceIndex;
DAC960_V2_PhysicalDeviceInfo_T *PhysicalDeviceInfo =
Controller->V2.PhysicalDeviceInformation[PhysicalDeviceIndex];
- DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber;
+ DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
+ Controller->V2.InquiryUnitSerialNumber[PhysicalDeviceIndex];
+ unsigned int DeviceIndex;
+ while (PhysicalDeviceInfo != NULL &&
+ (NewPhysicalDeviceInfo->Channel >
+ PhysicalDeviceInfo->Channel ||
+ (NewPhysicalDeviceInfo->Channel ==
+ PhysicalDeviceInfo->Channel &&
+ (NewPhysicalDeviceInfo->TargetID >
+ PhysicalDeviceInfo->TargetID ||
+ (NewPhysicalDeviceInfo->TargetID ==
+ PhysicalDeviceInfo->TargetID &&
+ NewPhysicalDeviceInfo->LogicalUnit >
+ PhysicalDeviceInfo->LogicalUnit)))))
+ {
+ DAC960_Critical("Physical Device %d:%d No Longer Exists\n",
+ Controller,
+ PhysicalDeviceInfo->Channel,
+ PhysicalDeviceInfo->TargetID);
+ Controller->V2.PhysicalDeviceInformation
+ [PhysicalDeviceIndex] = NULL;
+ Controller->V2.InquiryUnitSerialNumber
+ [PhysicalDeviceIndex] = NULL;
+ kfree(PhysicalDeviceInfo);
+ kfree(InquiryUnitSerialNumber);
+ for (DeviceIndex = PhysicalDeviceIndex;
+ DeviceIndex < DAC960_V2_MaxPhysicalDevices - 1;
+ DeviceIndex++)
+ {
+ Controller->V2.PhysicalDeviceInformation[DeviceIndex] =
+ Controller->V2.PhysicalDeviceInformation[DeviceIndex+1];
+ Controller->V2.InquiryUnitSerialNumber[DeviceIndex] =
+ Controller->V2.InquiryUnitSerialNumber[DeviceIndex+1];
+ }
+ Controller->V2.PhysicalDeviceInformation
+ [DAC960_V2_MaxPhysicalDevices-1] = NULL;
+ Controller->V2.InquiryUnitSerialNumber
+ [DAC960_V2_MaxPhysicalDevices-1] = NULL;
+ PhysicalDeviceInfo =
+ Controller->V2.PhysicalDeviceInformation[PhysicalDeviceIndex];
+ InquiryUnitSerialNumber =
+ Controller->V2.InquiryUnitSerialNumber[PhysicalDeviceIndex];
+ }
if (PhysicalDeviceInfo == NULL ||
(NewPhysicalDeviceInfo->Channel !=
PhysicalDeviceInfo->Channel) ||
(NewPhysicalDeviceInfo->LogicalUnit !=
PhysicalDeviceInfo->LogicalUnit))
{
- unsigned int DeviceIndex;
PhysicalDeviceInfo = (DAC960_V2_PhysicalDeviceInfo_T *)
kmalloc(sizeof(DAC960_V2_PhysicalDeviceInfo_T), GFP_ATOMIC);
InquiryUnitSerialNumber =
(DAC960_SCSI_Inquiry_UnitSerialNumber_T *)
kmalloc(sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T),
GFP_ATOMIC);
- if (InquiryUnitSerialNumber == NULL)
+ if (InquiryUnitSerialNumber == NULL &&
+ PhysicalDeviceInfo != NULL)
{
kfree(PhysicalDeviceInfo);
PhysicalDeviceInfo = NULL;
? "" : " - Allocation Failed"));
if (PhysicalDeviceInfo != NULL)
{
- for (DeviceIndex = PhysicalDeviceIndex;
- DeviceIndex < DAC960_V2_MaxPhysicalDevices - 1;
- DeviceIndex++)
- {
- Controller->V2.PhysicalDeviceInformation[DeviceIndex+1] =
- Controller->V2.PhysicalDeviceInformation[DeviceIndex];
- Controller->V2.InquiryUnitSerialNumber[DeviceIndex+1] =
- Controller->V2.InquiryUnitSerialNumber[DeviceIndex];
- Controller->V2.PhysicalDeviceInformation
- [PhysicalDeviceIndex] =
- PhysicalDeviceInfo;
- Controller->V2.InquiryUnitSerialNumber
- [PhysicalDeviceIndex] =
- InquiryUnitSerialNumber;
- }
memset(PhysicalDeviceInfo, 0,
sizeof(DAC960_V2_PhysicalDeviceInfo_T));
PhysicalDeviceInfo->PhysicalDeviceState =
memset(InquiryUnitSerialNumber, 0,
sizeof(DAC960_SCSI_Inquiry_UnitSerialNumber_T));
InquiryUnitSerialNumber->PeripheralDeviceType = 0x1F;
+ for (DeviceIndex = DAC960_V2_MaxPhysicalDevices - 1;
+ DeviceIndex > PhysicalDeviceIndex;
+ DeviceIndex--)
+ {
+ Controller->V2.PhysicalDeviceInformation[DeviceIndex] =
+ Controller->V2.PhysicalDeviceInformation[DeviceIndex-1];
+ Controller->V2.InquiryUnitSerialNumber[DeviceIndex] =
+ Controller->V2.InquiryUnitSerialNumber[DeviceIndex-1];
+ }
+ Controller->V2.PhysicalDeviceInformation
+ [PhysicalDeviceIndex] =
+ PhysicalDeviceInfo;
+ Controller->V2.InquiryUnitSerialNumber
+ [PhysicalDeviceIndex] =
+ InquiryUnitSerialNumber;
Controller->V2.NeedDeviceSerialNumberInformation = true;
}
}
NewPhysicalDeviceInfo
->PredictedFailuresDetected);
}
- if (PhysicalDeviceInfo->PhysicalDeviceState
- == DAC960_V2_Device_Dead &&
+ if ((PhysicalDeviceInfo->PhysicalDeviceState
+ == DAC960_V2_Device_Dead ||
+ PhysicalDeviceInfo->PhysicalDeviceState
+ == DAC960_V2_Device_InvalidState) &&
NewPhysicalDeviceInfo->PhysicalDeviceState
!= DAC960_V2_Device_Dead)
Controller->V2.NeedDeviceSerialNumberInformation = true;
Controller->V2.PhysicalDeviceIndex++;
}
else if (CommandOpcode == DAC960_V2_GetPhysicalDeviceInfoValid)
- Controller->V2.NeedPhysicalDeviceInformation = false;
+ {
+ unsigned int DeviceIndex;
+ for (DeviceIndex = Controller->V2.PhysicalDeviceIndex;
+ DeviceIndex < DAC960_V2_MaxPhysicalDevices;
+ DeviceIndex++)
+ {
+ DAC960_V2_PhysicalDeviceInfo_T *PhysicalDeviceInfo =
+ Controller->V2.PhysicalDeviceInformation[DeviceIndex];
+ DAC960_SCSI_Inquiry_UnitSerialNumber_T *InquiryUnitSerialNumber =
+ Controller->V2.InquiryUnitSerialNumber[DeviceIndex];
+ if (PhysicalDeviceInfo == NULL) break;
+ DAC960_Critical("Physical Device %d:%d No Longer Exists\n",
+ Controller,
+ PhysicalDeviceInfo->Channel,
+ PhysicalDeviceInfo->TargetID);
+ Controller->V2.PhysicalDeviceInformation[DeviceIndex] = NULL;
+ Controller->V2.InquiryUnitSerialNumber[DeviceIndex] = NULL;
+ kfree(PhysicalDeviceInfo);
+ kfree(InquiryUnitSerialNumber);
+ }
+ Controller->V2.NeedPhysicalDeviceInformation = false;
+ }
else if (CommandOpcode == DAC960_V2_GetLogicalDeviceInfoValid &&
CommandStatus == DAC960_V2_NormalCompletion)
{
NewLogicalDeviceInfo
->PatrolOperationBlockNumber,
LogicalDeviceSize);
+ if (LogicalDeviceInfo->BackgroundInitializationInProgress &&
+ !NewLogicalDeviceInfo->BackgroundInitializationInProgress)
+ DAC960_Progress("Logical Drive %d (/dev/rd/c%dd%d) "
+ "Background Initialization %s\n",
+ Controller,
+ LogicalDeviceNumber,
+ Controller->ControllerNumber,
+ LogicalDeviceNumber,
+ (NewLogicalDeviceInfo->LogicalDeviceControl
+ .LogicalDeviceInitialized
+ ? "Completed" : "Failed"));
memcpy(LogicalDeviceInfo, NewLogicalDeviceInfo,
sizeof(DAC960_V2_LogicalDeviceInfo_T));
}
+ Controller->V2.LogicalDriveFoundDuringScan
+ [LogicalDeviceNumber] = true;
NewLogicalDeviceInfo->LogicalDeviceNumber++;
}
else if (CommandOpcode == DAC960_V2_GetLogicalDeviceInfoValid)
- Controller->V2.NeedLogicalDeviceInformation = false;
+ {
+ int LogicalDriveNumber;
+ for (LogicalDriveNumber = 0;
+ LogicalDriveNumber < DAC960_MaxLogicalDrives;
+ LogicalDriveNumber++)
+ {
+ DAC960_V2_LogicalDeviceInfo_T *LogicalDeviceInfo =
+ Controller->V2.LogicalDeviceInformation[LogicalDriveNumber];
+ if (LogicalDeviceInfo == NULL ||
+ Controller->V2.LogicalDriveFoundDuringScan
+ [LogicalDriveNumber])
+ continue;
+ DAC960_Critical("Logical Drive %d (/dev/rd/c%dd%d) "
+ "No Longer Exists\n", Controller,
+ LogicalDriveNumber,
+ Controller->ControllerNumber,
+ LogicalDriveNumber);
+ Controller->V2.LogicalDeviceInformation
+ [LogicalDriveNumber] = NULL;
+ kfree(LogicalDeviceInfo);
+ Controller->LogicalDriveInitiallyAccessible
+ [LogicalDriveNumber] = false;
+ }
+ Controller->V2.NeedLogicalDeviceInformation = false;
+ }
if (Controller->V2.HealthStatusBuffer->NextEventSequenceNumber
- Controller->V2.NextEventSequenceNumber > 0)
{
CommandMailbox->GetEvent.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(&Controller->V2.Event);
+ Virtual_to_Bus64(&Controller->V2.Event);
CommandMailbox->GetEvent.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
CommandMailbox->SCSI_10.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(InquiryUnitSerialNumber);
+ Virtual_to_Bus64(InquiryUnitSerialNumber);
CommandMailbox->SCSI_10.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
Controller->V2.NeedDeviceSerialNumberInformation = false;
return;
}
+ if (Controller->V2.StartPhysicalDeviceInformationScan)
+ {
+ Controller->V2.PhysicalDeviceIndex = 0;
+ Controller->V2.NewPhysicalDeviceInformation.Channel = 0;
+ Controller->V2.NewPhysicalDeviceInformation.TargetID = 0;
+ Controller->V2.NewPhysicalDeviceInformation.LogicalUnit = 0;
+ Controller->V2.StartPhysicalDeviceInformationScan = false;
+ }
CommandMailbox->PhysicalDeviceInfo.CommandOpcode = DAC960_V2_IOCTL;
CommandMailbox->PhysicalDeviceInfo.DataTransferSize =
sizeof(DAC960_V2_PhysicalDeviceInfo_T);
CommandMailbox->PhysicalDeviceInfo.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(&Controller->V2.NewPhysicalDeviceInformation);
+ Virtual_to_Bus64(&Controller->V2.NewPhysicalDeviceInformation);
CommandMailbox->PhysicalDeviceInfo.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
}
if (Controller->V2.NeedLogicalDeviceInformation)
{
+ if (Controller->V2.StartLogicalDeviceInformationScan)
+ {
+ int LogicalDriveNumber;
+ for (LogicalDriveNumber = 0;
+ LogicalDriveNumber < DAC960_MaxLogicalDrives;
+ LogicalDriveNumber++)
+ Controller->V2.LogicalDriveFoundDuringScan
+ [LogicalDriveNumber] = false;
+ Controller->V2.NewLogicalDeviceInformation
+ .LogicalDeviceNumber = 0;
+ Controller->V2.StartLogicalDeviceInformationScan = false;
+ }
CommandMailbox->LogicalDeviceInfo.CommandOpcode = DAC960_V2_IOCTL;
CommandMailbox->LogicalDeviceInfo.DataTransferSize =
sizeof(DAC960_V2_LogicalDeviceInfo_T);
CommandMailbox->LogicalDeviceInfo.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(&Controller->V2.NewLogicalDeviceInformation);
+ Virtual_to_Bus64(&Controller->V2.NewLogicalDeviceInformation);
CommandMailbox->LogicalDeviceInfo.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
DAC960_V1_ClearCommand(Command);
Command->CommandType = DAC960_MonitoringCommand;
CommandMailbox->Type3.CommandOpcode = DAC960_V1_Enquiry;
- CommandMailbox->Type3.BusAddress = Virtual_to_Bus(&Controller->V1.NewEnquiry);
+ CommandMailbox->Type3.BusAddress =
+ Virtual_to_Bus32(&Controller->V1.NewEnquiry);
DAC960_QueueCommand(Command);
}
CommandMailbox->ControllerInfo.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(&Controller->V2.NewControllerInformation);
+ Virtual_to_Bus64(&Controller->V2.NewControllerInformation);
CommandMailbox->ControllerInfo.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
&Controller->V2.ControllerInformation;
unsigned int StatusChangeCounter =
Controller->V2.HealthStatusBuffer->StatusChangeCounter;
+ boolean ForceMonitoringCommand = false;
+ if (jiffies - Controller->SecondaryMonitoringTime
+ > DAC960_SecondaryMonitoringInterval)
+ {
+ int LogicalDriveNumber;
+ for (LogicalDriveNumber = 0;
+ LogicalDriveNumber < DAC960_MaxLogicalDrives;
+ LogicalDriveNumber++)
+ {
+ DAC960_V2_LogicalDeviceInfo_T *LogicalDeviceInfo =
+ Controller->V2.LogicalDeviceInformation[LogicalDriveNumber];
+ if (LogicalDeviceInfo == NULL) continue;
+ if (!LogicalDeviceInfo->LogicalDeviceControl
+ .LogicalDeviceInitialized &&
+ Controller->LogicalDriveUsageCount[LogicalDriveNumber] > 0)
+ {
+ ForceMonitoringCommand = true;
+ break;
+ }
+ }
+ Controller->SecondaryMonitoringTime = jiffies;
+ }
if (StatusChangeCounter == Controller->V2.StatusChangeCounter &&
Controller->V2.HealthStatusBuffer->NextEventSequenceNumber
== Controller->V2.NextEventSequenceNumber &&
ControllerInfo->RebuildsActive +
ControllerInfo->OnlineExpansionsActive == 0 ||
jiffies - Controller->PrimaryMonitoringTime
- < DAC960_MonitoringTimerInterval))
+ < DAC960_MonitoringTimerInterval) &&
+ !ForceMonitoringCommand)
{
Controller->MonitoringTimer.expires =
jiffies + DAC960_HealthStatusMonitoringInterval;
DiskGeometry_T Geometry, *UserGeometry;
DAC960_Controller_T *Controller;
int PartitionNumber;
- if (File == NULL) return -EINVAL;
- if (File->f_flags & O_NONBLOCK)
+ if (File != NULL && (File->f_flags & O_NONBLOCK))
return DAC960_UserIOCTL(Inode, File, Request, Argument);
if (ControllerNumber < 0 || ControllerNumber > DAC960_ControllerCount - 1)
return -ENXIO;
if (CommandOpcode == DAC960_V1_DCDB)
{
DAC960_AcquireControllerLock(Controller, &ProcessorFlags);
- while (Controller->V1.DirectCommandActive[DCDB.Channel]
- [DCDB.TargetID] ||
- (Command = DAC960_AllocateCommand(Controller)) == NULL)
+ while ((Command = DAC960_AllocateCommand(Controller)) == NULL)
DAC960_WaitForCommand(Controller);
+ while (Controller->V1.DirectCommandActive[DCDB.Channel]
+ [DCDB.TargetID])
+ {
+ spin_unlock_irq(&io_request_lock);
+ __wait_event(Controller->CommandWaitQueue,
+ !Controller->V1.DirectCommandActive
+ [DCDB.Channel][DCDB.TargetID]);
+ spin_lock_irq(&io_request_lock);
+ }
Controller->V1.DirectCommandActive[DCDB.Channel]
[DCDB.TargetID] = true;
DAC960_ReleaseControllerLock(Controller, &ProcessorFlags);
memcpy(&Command->V1.CommandMailbox, &UserCommand.CommandMailbox,
sizeof(DAC960_V1_CommandMailbox_T));
Command->V1.CommandMailbox.Type3.BusAddress =
- Virtual_to_Bus(&DCDB);
- DCDB.BusAddress = Virtual_to_Bus(DataTransferBuffer);
+ Virtual_to_Bus32(&DCDB);
+ DCDB.BusAddress = Virtual_to_Bus32(DataTransferBuffer);
}
else
{
sizeof(DAC960_V1_CommandMailbox_T));
if (DataTransferBuffer != NULL)
Command->V1.CommandMailbox.Type3.BusAddress =
- Virtual_to_Bus(DataTransferBuffer);
+ Virtual_to_Bus32(DataTransferBuffer);
}
DAC960_ExecuteCommand(Command);
CommandStatus = Command->V1.CommandStatus;
CommandMailbox->Common.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(DataTransferBuffer);
+ Virtual_to_Bus64(DataTransferBuffer);
CommandMailbox->Common.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
.NoAutoRequestSense = false;
CommandMailbox->Common.RequestSenseSize = RequestSenseLength;
CommandMailbox->Common.RequestSenseBusAddress =
- Virtual_to_Bus(RequestSenseBuffer);
+ Virtual_to_Bus64(RequestSenseBuffer);
}
DAC960_ExecuteCommand(Command);
CommandStatus = Command->V2.CommandStatus;
memcpy(&Command->V1.CommandMailbox, &KernelCommand->CommandMailbox,
sizeof(DAC960_V1_CommandMailbox_T));
Command->V1.CommandMailbox.Type3.BusAddress =
- Virtual_to_Bus(DCDB);
+ Virtual_to_Bus32(DCDB);
Command->V1.KernelCommand = KernelCommand;
- DCDB->BusAddress = Virtual_to_Bus(DataTransferBuffer);
+ DCDB->BusAddress = Virtual_to_Bus32(DataTransferBuffer);
DAC960_QueueCommand(Command);
DAC960_ReleaseControllerLock(Controller, &ProcessorFlags);
}
sizeof(DAC960_V1_CommandMailbox_T));
if (DataTransferBuffer != NULL)
Command->V1.CommandMailbox.Type3.BusAddress =
- Virtual_to_Bus(DataTransferBuffer);
+ Virtual_to_Bus32(DataTransferBuffer);
Command->V1.KernelCommand = KernelCommand;
DAC960_QueueCommand(Command);
DAC960_ReleaseControllerLock(Controller, &ProcessorFlags);
CommandMailbox->Common.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(DataTransferBuffer);
+ Virtual_to_Bus64(DataTransferBuffer);
CommandMailbox->Common.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
CommandMailbox->Common.CommandControlBits
.NoAutoRequestSense = false;
CommandMailbox->Common.RequestSenseBusAddress =
- Virtual_to_Bus(RequestSenseBuffer);
+ Virtual_to_Bus64(RequestSenseBuffer);
}
Command->V2.KernelCommand = KernelCommand;
DAC960_QueueCommand(Command);
CommandMailbox->Type3R.CommandOpcode = DAC960_V1_RebuildControl;
CommandMailbox->Type3R.RebuildRateConstant = 0xFF;
CommandMailbox->Type3R.BusAddress =
- Virtual_to_Bus(&OldRebuildRateConstant);
+ Virtual_to_Bus32(&OldRebuildRateConstant);
DAC960_ExecuteCommand(Command);
switch (Command->V1.CommandStatus)
{
CommandMailbox->Common.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentDataPointer =
- Virtual_to_Bus(&PhysicalToLogicalDevice);
+ Virtual_to_Bus64(&PhysicalToLogicalDevice);
CommandMailbox->Common.DataTransferMemoryAddress
.ScatterGatherSegments[0]
.SegmentByteCount =
Linux Driver for Mylex DAC960/AcceleRAID/eXtremeRAID PCI RAID Controllers
- Copyright 1998-2000 by Leonard N. Zubkoff <lnz@dandelion.com>
+ Copyright 1998-2001 by Leonard N. Zubkoff <lnz@dandelion.com>
This program is free software; you may redistribute and/or modify it under
the terms of the GNU General Public License Version 2 as published by the
DAC960_V1_ClearBadDataTable = 0x26,
DAC960_V1_GetErrorTable = 0x17,
DAC960_V1_AddCapacityAsync = 0x2A,
+ DAC960_V1_BackgroundInitializationControl = 0x2B,
/* Configuration Related Commands */
DAC960_V1_ReadConfig2 = 0x3D,
DAC960_V1_WriteConfig2 = 0x3C,
unsigned int NonVolatileMemorySize; /* Bytes 36-39 */
struct {
enum {
- DAC960_V1_DRAM = 0x0,
- DAC960_V1_EDO = 0x1,
- DAC960_V1_SDRAM = 0x2
+ DAC960_V1_RamType_DRAM = 0x0,
+ DAC960_V1_RamType_EDO = 0x1,
+ DAC960_V1_RamType_SDRAM = 0x2,
+ DAC960_V1_RamType_Last = 0x7
} __attribute__ ((packed)) RamType:3; /* Byte 40 Bits 0-2 */
enum {
- DAC960_V1_None = 0x0,
- DAC960_V1_Parity = 0x1,
- DAC960_V1_ECC = 0x2
+ DAC960_V1_ErrorCorrection_None = 0x0,
+ DAC960_V1_ErrorCorrection_Parity = 0x1,
+ DAC960_V1_ErrorCorrection_ECC = 0x2,
+ DAC960_V1_ErrorCorrection_Last = 0x7
} __attribute__ ((packed)) ErrorCorrection:3; /* Byte 40 Bits 3-5 */
boolean FastPageMode:1; /* Byte 40 Bit 6 */
boolean LowPowerMemory:1; /* Byte 40 Bit 7 */
struct {
boolean Clustering:1; /* Byte 116 Bit 0 */
boolean MylexOnlineRAIDExpansion:1; /* Byte 116 Bit 1 */
- unsigned int :30; /* Bytes 116-119 */
+ boolean ReadAhead:1; /* Byte 116 Bit 2 */
+ boolean BackgroundInitialization:1; /* Byte 116 Bit 3 */
+ unsigned int :28; /* Bytes 116-119 */
} FirmwareFeatures;
unsigned int :32; /* Bytes 120-123 */
unsigned int :32; /* Bytes 124-127 */
DAC960_V2_MemoryType_DRAM = 0x01,
DAC960_V2_MemoryType_EDRAM = 0x02,
DAC960_V2_MemoryType_EDO = 0x03,
- DAC960_V2_MemoryType_SDRAM = 0x04
+ DAC960_V2_MemoryType_SDRAM = 0x04,
+ DAC960_V2_MemoryType_Last = 0x1F
} __attribute__ ((packed)) MemoryType:5; /* Byte 0 Bits 0-4 */
boolean :1; /* Byte 0 Bit 5 */
boolean MemoryParity:1; /* Byte 0 Bit 6 */
DAC960_V2_ReadCacheDisabled = 0x0,
DAC960_V2_ReadCacheEnabled = 0x1,
DAC960_V2_ReadAheadEnabled = 0x2,
- DAC960_V2_IntelligentReadAheadEnabled = 0x3
+ DAC960_V2_IntelligentReadAheadEnabled = 0x3,
+ DAC960_V2_ReadCache_Last = 0x7
} __attribute__ ((packed)) ReadCache:3; /* Byte 8 Bits 0-2 */
enum {
DAC960_V2_WriteCacheDisabled = 0x0,
DAC960_V2_LogicalDeviceReadOnly = 0x1,
DAC960_V2_WriteCacheEnabled = 0x2,
- DAC960_V2_IntelligentWriteCacheEnabled = 0x3
+ DAC960_V2_IntelligentWriteCacheEnabled = 0x3,
+ DAC960_V2_WriteCache_Last = 0x7
} __attribute__ ((packed)) WriteCache:3; /* Byte 8 Bits 3-5 */
boolean :1; /* Byte 8 Bit 6 */
boolean LogicalDeviceInitialized:1; /* Byte 8 Bit 7 */
boolean NeedDeviceSerialNumberInformation;
boolean NeedRebuildProgress;
boolean NeedConsistencyCheckProgress;
+ boolean StartDeviceStateScan;
boolean RebuildProgressFirst;
boolean RebuildFlagPending;
boolean RebuildStatusPending;
boolean NeedLogicalDeviceInformation;
boolean NeedPhysicalDeviceInformation;
boolean NeedDeviceSerialNumberInformation;
+ boolean StartLogicalDeviceInformationScan;
+ boolean StartPhysicalDeviceInformationScan;
DAC960_V2_CommandMailbox_T *FirstCommandMailbox;
DAC960_V2_CommandMailbox_T *LastCommandMailbox;
DAC960_V2_CommandMailbox_T *NextCommandMailbox;
DAC960_V2_PhysicalDevice_T
LogicalDriveToVirtualDevice[DAC960_MaxLogicalDrives];
DAC960_V2_Event_T Event;
+ boolean LogicalDriveFoundDuringScan[DAC960_MaxLogicalDrives];
} V2;
} FW;
DiskPartition_T DiskPartitions[DAC960_MinorCount];
/*
- Virtual_to_Bus maps from Kernel Virtual Addresses to PCI Bus Addresses.
+ Virtual_to_Bus32 maps from Kernel Virtual Addresses to 32 Bit PCI Bus
+ Addresses.
*/
-static inline DAC960_BusAddress32_T Virtual_to_Bus(void *VirtualAddress)
+static inline DAC960_BusAddress32_T Virtual_to_Bus32(void *VirtualAddress)
{
return (DAC960_BusAddress32_T) virt_to_bus(VirtualAddress);
}
/*
- Bus_to_Virtual maps from PCI Bus Addresses to Kernel Virtual Addresses.
+ Bus32_to_Virtual maps from 32 Bit PCI Bus Addresses to Kernel Virtual
+ Addresses.
*/
-static inline void *Bus_to_Virtual(DAC960_BusAddress32_T BusAddress)
+static inline void *Bus32_to_Virtual(DAC960_BusAddress32_T BusAddress)
{
return (void *) bus_to_virt(BusAddress);
}
+/*
+ Virtual_to_Bus64 maps from Kernel Virtual Addresses to 64 Bit PCI Bus
+ Addresses.
+*/
+
+static inline DAC960_BusAddress64_T Virtual_to_Bus64(void *VirtualAddress)
+{
+ return (DAC960_BusAddress64_T) virt_to_bus(VirtualAddress);
+}
+
+
/*
Define the DAC960 BA Series Controller Interface Register Offsets.
*/
void DAC960_BA_WriteHardwareMailbox(void *ControllerBaseAddress,
DAC960_V2_CommandMailbox_T *CommandMailbox)
{
- writel(Virtual_to_Bus(CommandMailbox),
+#ifdef __ia64__
+ writeq(Virtual_to_Bus64(CommandMailbox),
+ ControllerBaseAddress + DAC960_BA_CommandMailboxBusAddressOffset);
+#else
+ writel(Virtual_to_Bus32(CommandMailbox),
ControllerBaseAddress + DAC960_BA_CommandMailboxBusAddressOffset);
+#endif
}
static inline DAC960_V2_CommandIdentifier_T
void DAC960_LP_WriteHardwareMailbox(void *ControllerBaseAddress,
DAC960_V2_CommandMailbox_T *CommandMailbox)
{
- writel(Virtual_to_Bus(CommandMailbox),
+#ifdef __ia64__
+ writeq(Virtual_to_Bus64(CommandMailbox),
ControllerBaseAddress + DAC960_LP_CommandMailboxBusAddressOffset);
+#else
+ writel(Virtual_to_Bus32(CommandMailbox),
+ ControllerBaseAddress + DAC960_LP_CommandMailboxBusAddressOffset);
+#endif
}
static inline DAC960_V2_CommandIdentifier_T
/*
- * $Id: b1.c,v 1.20 2000/11/23 20:45:14 kai Exp $
+ * $Id: b1.c,v 1.20.6.1 2001/02/13 11:43:29 kai Exp $
*
* Common module for AVM B1 cards.
*
* (c) Copyright 1999 by Carsten Paeth (calle@calle.in-berlin.de)
*
* $Log: b1.c,v $
+ * Revision 1.20.6.1 2001/02/13 11:43:29 kai
+ * more compatility changes for 2.2.19
+ *
* Revision 1.20 2000/11/23 20:45:14 kai
* fixed module_init/exit stuff
* Note: compiled-in kernel doesn't work pre 2.2.18 anymore.
/*
- * $Id: b1dma.c,v 1.11 2000/11/19 17:02:47 kai Exp $
+ * $Id: b1dma.c,v 1.11.6.1 2001/02/13 11:43:29 kai Exp $
*
* Common module for AVM B1 cards that support dma with AMCC
*
* (c) Copyright 2000 by Carsten Paeth (calle@calle.in-berlin.de)
*
* $Log: b1dma.c,v $
+ * Revision 1.11.6.1 2001/02/13 11:43:29 kai
+ * more compatility changes for 2.2.19
+ *
* Revision 1.11 2000/11/19 17:02:47 kai
* compatibility cleanup - part 3
*
/*
- * $Id: b1isa.c,v 1.10 2000/11/23 20:45:14 kai Exp $
+ * $Id: b1isa.c,v 1.10.6.1 2001/02/13 11:43:29 kai Exp $
*
* Module for AVM B1 ISA-card.
*
* (c) Copyright 1999 by Carsten Paeth (calle@calle.in-berlin.de)
*
* $Log: b1isa.c,v $
+ * Revision 1.10.6.1 2001/02/13 11:43:29 kai
+ * more compatility changes for 2.2.19
+ *
* Revision 1.10 2000/11/23 20:45:14 kai
* fixed module_init/exit stuff
* Note: compiled-in kernel doesn't work pre 2.2.18 anymore.
param.port = dev->base_address[ 2] & PCI_BASE_ADDRESS_IO_MASK;
param.irq = dev->irq;
- retval = pci_enable_device (dev);
- if (retval != 0) {
- printk(KERN_ERR
- "%s: failed to enable AVM-B1 V4 at i/o %#x, irq %d, mem %#x err=%d\n",
- driver->name, param.port, param.irq, param.membase, retval);
- MOD_DEC_USE_COUNT;
- return -EIO;
- }
printk(KERN_INFO
"%s: PCI BIOS reports AVM-B1 V4 at i/o %#x, irq %d, mem %#x\n",
param.port = dev->base_address[ 1] & PCI_BASE_ADDRESS_IO_MASK;
param.irq = dev->irq;
- retval = pci_enable_device (dev);
- if (retval != 0) {
- printk(KERN_ERR
- "%s: failed to enable AVM-B1 at i/o %#x, irq %d, err=%d\n",
- driver->name, param.port, param.irq, retval);
- MOD_DEC_USE_COUNT;
- return -EIO;
- }
printk(KERN_INFO
"%s: PCI BIOS reports AVM-B1 at i/o %#x, irq %d\n",
driver->name, param.port, param.irq);
while ((dev = pci_find_device(PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_B1, dev))) {
retval = add_card(dev);
if (retval != 0) {
+ detach_capi_driver(driver);
+#ifdef CONFIG_ISDN_DRV_AVMB1_B1PCIV4
+ detach_capi_driver(driverv4);
+#endif
MOD_DEC_USE_COUNT;
return retval;
}
return 0;
}
printk(KERN_ERR "%s: NO B1-PCI card detected\n", driver->name);
+ detach_capi_driver(driver);
+#ifdef CONFIG_ISDN_DRV_AVMB1_B1PCIV4
+ detach_capi_driver(driverv4);
+#endif
MOD_DEC_USE_COUNT;
return -ESRCH;
#else
/*
- * $Id: b1pcmcia.c,v 1.12 2000/11/23 20:45:14 kai Exp $
+ * $Id: b1pcmcia.c,v 1.12.6.1 2001/02/13 11:43:29 kai Exp $
*
* Module for AVM B1/M1/M2 PCMCIA-card.
*
* (c) Copyright 1999 by Carsten Paeth (calle@calle.in-berlin.de)
*
* $Log: b1pcmcia.c,v $
+ * Revision 1.12.6.1 2001/02/13 11:43:29 kai
+ * more compatility changes for 2.2.19
+ *
* Revision 1.12 2000/11/23 20:45:14 kai
* fixed module_init/exit stuff
* Note: compiled-in kernel doesn't work pre 2.2.18 anymore.
#include "capilli.h"
#include "avmcard.h"
-static char *revision = "$Revision: 1.12 $";
+static char *revision = "$Revision: 1.12.6.1 $";
/* ------------------------------------------------------------- */
/*
- * $Id: c4.c,v 1.20.6.1 2000/11/28 12:02:45 kai Exp $
+ * $Id: c4.c,v 1.20.6.2 2001/02/13 11:43:29 kai Exp $
*
* Module for AVM C4 card.
*
* (c) Copyright 1999 by Carsten Paeth (calle@calle.in-berlin.de)
*
* $Log: c4.c,v $
+ * Revision 1.20.6.2 2001/02/13 11:43:29 kai
+ * more compatility changes for 2.2.19
+ *
* Revision 1.20.6.1 2000/11/28 12:02:45 kai
* MODULE_DEVICE_TABLE for 2.4
*
#include "capilli.h"
#include "avmcard.h"
-static char *revision = "$Revision: 1.20.6.1 $";
+static char *revision = "$Revision: 1.20.6.2 $";
#undef CONFIG_C4_DEBUG
#undef CONFIG_C4_POLLDEBUG
param.irq = dev->irq;
param.membase = dev->base_address[ 0] & PCI_BASE_ADDRESS_MEM_MASK;
- retval = pci_enable_device (dev);
- if (retval != 0) {
- printk(KERN_ERR
- "%s: failed to enable AVM-C4 at i/o %#x, irq %d, mem %#x err=%d\n",
- driver->name, param.port, param.irq, param.membase, retval);
- MOD_DEC_USE_COUNT;
- return -EIO;
- }
printk(KERN_INFO
"%s: PCI BIOS reports AVM-C4 at i/o %#x, irq %d, mem %#x\n",
printk(KERN_ERR
"%s: no AVM-C4 at i/o %#x, irq %d detected, mem %#x\n",
driver->name, param.port, param.irq, param.membase);
+ detach_capi_driver(driver);
MOD_DEC_USE_COUNT;
return retval;
}
return 0;
}
printk(KERN_ERR "%s: NO C4 card detected\n", driver->name);
+ detach_capi_driver(driver);
MOD_DEC_USE_COUNT;
return -ESRCH;
#else
/*
- * $Id: capi.c,v 1.44.6.4 2001/02/10 14:41:20 kai Exp $
+ * $Id: capi.c,v 1.44.6.5 2001/02/13 11:43:29 kai Exp $
*
* CAPI 2.0 Interface for Linux
*
* Copyright 1996 by Carsten Paeth (calle@calle.in-berlin.de)
*
* $Log: capi.c,v $
+ * Revision 1.44.6.5 2001/02/13 11:43:29 kai
+ * more compatility changes for 2.2.19
+ *
* Revision 1.44.6.4 2001/02/10 14:41:20 kai
* Changes from kernel tree
*
#include "capifs.h"
#endif
-static char *revision = "$Revision: 1.44.6.4 $";
+static char *revision = "$Revision: 1.44.6.5 $";
MODULE_AUTHOR("Carsten Paeth (calle@calle.in-berlin.de)");
int capinc_tty_ioctl(struct tty_struct *tty, struct file * file,
unsigned int cmd, unsigned long arg)
{
- return -ENOIOCTLCMD;
+ int error = 0;
+ switch (cmd) {
+ default:
+ error = n_tty_ioctl (tty, file, cmd, arg);
+ break;
+ }
+ return error;
}
void capinc_tty_set_termios(struct tty_struct *tty, struct termios * old)
{
struct capidev *cdev;
int len = 0;
- off_t begin = 0;
for (cdev=capidev_openlist; cdev; cdev = cdev->next) {
len += sprintf(page+len, "%d %d %lu %lu %lu %lu\n",
cdev->nrecvdatapkt,
cdev->nsentctlpkt,
cdev->nsentdatapkt);
- if (len+begin > off+count)
- goto endloop;
- if (len+begin < off) {
- begin += len;
+ if (len <= off) {
+ off -= len;
len = 0;
+ } else {
+ if (len-off > count)
+ goto endloop;
}
}
endloop:
- if (cdev == 0)
+ if (len < count)
*eof = 1;
- if (off >= len+begin)
- return 0;
- *start = page + (off-begin);
- return ((count < begin+len-off) ? count : begin+len-off);
+ if (len>count) len = count;
+ if (len<0) len = 0;
+ return len;
}
/*
struct capidev *cdev;
struct capincci *np;
int len = 0;
- off_t begin = 0;
for (cdev=capidev_openlist; cdev; cdev = cdev->next) {
for (np=cdev->nccis; np; np = np->next) {
#else /* CONFIG_ISDN_CAPI_MIDDLEWARE */
np->minorp && np->minorp->file ? " open" : "");
#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
- if (len+begin > off+count)
- goto endloop;
- if (len+begin < off) {
- begin += len;
+ if (len <= off) {
+ off -= len;
len = 0;
+ } else {
+ if (len-off > count)
+ goto endloop;
}
}
}
endloop:
- if (cdev == 0)
+ *start = page+off;
+ if (len < count)
*eof = 1;
- if (off >= len+begin)
- return 0;
- *start = page + (begin-off);
- return ((count < begin+len-off) ? count : begin+len-off);
+ if (len>count) len = count;
+ if (len<0) len = 0;
+ return len;
}
static struct procfsentries {
/*
- * $Id: capidrv.c,v 1.39.6.1 2001/02/10 14:41:20 kai Exp $
+ * $Id: capidrv.c,v 1.39.6.2 2001/02/13 11:43:29 kai Exp $
*
* ISDN4Linux Driver, using capi20 interface (kernelcapi)
*
* Copyright 1997 by Carsten Paeth (calle@calle.in-berlin.de)
*
* $Log: capidrv.c,v $
+ * Revision 1.39.6.2 2001/02/13 11:43:29 kai
+ * more compatility changes for 2.2.19
+ *
* Revision 1.39.6.1 2001/02/10 14:41:20 kai
* Changes from kernel tree
*
#include "capicmd.h"
#include "capidrv.h"
-static char *revision = "$Revision: 1.39.6.1 $";
+static char *revision = "$Revision: 1.39.6.2 $";
static int debugmode = 0;
MODULE_AUTHOR("Carsten Paeth <calle@calle.in-berlin.de>");
/*
- * $Id: capifs.c,v 1.14.6.2 2001/02/10 14:41:20 kai Exp $
+ * $Id: capifs.c,v 1.14.6.3 2001/02/13 11:43:29 kai Exp $
*
* (c) Copyright 2000 by Carsten Paeth (calle@calle.de)
*
* Heavily based on devpts filesystem from H. Peter Anvin
*
* $Log: capifs.c,v $
+ * Revision 1.14.6.3 2001/02/13 11:43:29 kai
+ * more compatility changes for 2.2.19
+ *
* Revision 1.14.6.2 2001/02/10 14:41:20 kai
* Changes from kernel tree
*
MODULE_AUTHOR("Carsten Paeth <calle@calle.de>");
-static char *revision = "$Revision: 1.14.6.2 $";
+static char *revision = "$Revision: 1.14.6.3 $";
struct capifs_ncci {
struct inode *inode;
ino_t ino = inode->i_ino;
struct capifs_sb_info *sbi = SBI(inode->i_sb);
- inode->i_op = NULL;
inode->i_mode = 0;
inode->i_nlink = 0;
- inode->i_size = 0;
inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode->i_blocks = 0;
inode->i_blksize = 1024;
return;
}
-
ino -= 2;
if ( ino >= sbi->max_ncci )
return; /* Bogus */
/*
- * $Id: capiutil.c,v 1.13 2000/11/23 20:45:14 kai Exp $
+ * $Id: capiutil.c,v 1.13.6.1 2001/02/13 11:43:29 kai Exp $
*
* CAPI 2.0 convert capi message to capi message struct
*
* Rewritten for Linux 1996 by Carsten Paeth (calle@calle.in-berlin.de)
*
* $Log: capiutil.c,v $
+ * Revision 1.13.6.1 2001/02/13 11:43:29 kai
+ * more compatility changes for 2.2.19
+ *
* Revision 1.13 2000/11/23 20:45:14 kai
* fixed module_init/exit stuff
* Note: compiled-in kernel doesn't work pre 2.2.18 anymore.
/*
- * $Id: kcapi.c,v 1.21.6.1 2000/12/10 23:39:19 kai Exp $
+ * $Id: kcapi.c,v 1.21.6.2 2001/02/13 11:43:29 kai Exp $
*
* Kernel CAPI 2.0 Module
*
* (c) Copyright 1999 by Carsten Paeth (calle@calle.in-berlin.de)
*
* $Log: kcapi.c,v $
+ * Revision 1.21.6.2 2001/02/13 11:43:29 kai
+ * more compatility changes for 2.2.19
+ *
* Revision 1.21.6.1 2000/12/10 23:39:19 kai
* in 2.4 we don't have tq_scheduler anymore.
* also add one supported card to hfc_pci.c
#include <linux/b1lli.h>
#endif
-static char *revision = "$Revision: 1.21.6.1 $";
+static char *revision = "$Revision: 1.21.6.2 $";
/* ------------------------------------------------------------- */
struct capi_appl *ap;
int i;
int len = 0;
- off_t begin = 0;
for (i=0; i < CAPI_MAXAPPL; i++) {
ap = &applications[i];
ap->rparam.datablklen,
ap->nncci,
skb_queue_len(&ap->recv_queue));
- if (len+begin > off+count)
- goto endloop;
- if (len+begin < off) {
- begin += len;
+ if (len <= off) {
+ off -= len;
len = 0;
+ } else {
+ if (len-off > count)
+ goto endloop;
}
}
endloop:
- if (i >= CAPI_MAXAPPL)
+ *start = page+off;
+ if (len < count)
*eof = 1;
- if (off >= len+begin)
- return 0;
- *start = page + (off-begin);
- return ((count < begin+len-off) ? count : begin+len-off);
+ if (len>count) len = count;
+ if (len<0) len = 0;
+ return len;
}
/*
struct capi_ncci *np;
int i;
int len = 0;
- off_t begin = 0;
for (i=0; i < CAPI_MAXAPPL; i++) {
ap = &applications[i];
np->ncci,
np->winsize,
np->nmsg);
- if (len+begin > off+count)
- goto endloop;
- if (len+begin < off) {
- begin += len;
+ if (len <= off) {
+ off -= len;
len = 0;
+ } else {
+ if (len-off > count)
+ goto endloop;
}
}
}
endloop:
- if (i >= CAPI_MAXAPPL)
+ *start = page+off;
+ if (len < count)
*eof = 1;
- if (off >= len+begin)
- return 0;
- *start = page + (off-begin);
- return ((count < begin+len-off) ? count : begin+len-off);
+ if (len>count) len = count;
+ if (len<0) len = 0;
+ return len;
}
/*
{
struct capi_driver *driver;
int len = 0;
- off_t begin = 0;
spin_lock(&drivers_lock);
for (driver = drivers; driver; driver = driver->next) {
driver->name,
driver->ncontroller,
driver->revision);
- if (len+begin > off+count)
- goto endloop;
- if (len+begin < off) {
- begin += len;
+ if (len <= off) {
+ off -= len;
len = 0;
+ } else {
+ if (len-off > count)
+ goto endloop;
}
}
endloop:
spin_unlock(&drivers_lock);
- if (!driver)
+ *start = page+off;
+ if (len < count)
*eof = 1;
- if (off >= len+begin)
- return 0;
- *start = page + (off-begin);
- return ((count < begin+len-off) ? count : begin+len-off);
+ if (len>count) len = count;
+ if (len<0) len = 0;
+ return len;
}
/*
{
struct capi_interface_user *cp;
int len = 0;
- off_t begin = 0;
spin_lock(&capi_users_lock);
for (cp = capi_users; cp ; cp = cp->next) {
len += sprintf(page+len, "%s\n", cp->name);
- if (len+begin > off+count)
- goto endloop;
- if (len+begin < off) {
- begin += len;
+ if (len <= off) {
+ off -= len;
len = 0;
+ } else {
+ if (len-off > count)
+ goto endloop;
}
}
endloop:
spin_unlock(&capi_users_lock);
- if (cp == 0)
+ *start = page+off;
+ if (len < count)
*eof = 1;
- if (off >= len+begin)
- return 0;
- *start = page + (off-begin);
- return ((count < begin+len-off) ? count : begin+len-off);
+ if (len>count) len = count;
+ if (len<0) len = 0;
+ return len;
}
/*
struct capi_ctr *cp;
int i;
int len = 0;
- off_t begin = 0;
for (i=0; i < CAPI_MAXCONTR; i++) {
cp = &cards[i];
cp->name,
cp->driver->procinfo ? cp->driver->procinfo(cp) : ""
);
- if (len+begin > off+count)
- goto endloop;
- if (len+begin < off) {
- begin += len;
+ if (len <= off) {
+ off -= len;
len = 0;
+ } else {
+ if (len-off > count)
+ goto endloop;
}
}
endloop:
- if (i >= CAPI_MAXCONTR)
+ *start = page+off;
+ if (len < count)
*eof = 1;
- if (off >= len+begin)
- return 0;
- *start = page + (off-begin);
- return ((count < begin+len-off) ? count : begin+len-off);
+ if (len>count) len = count;
+ if (len<0) len = 0;
+ return len;
}
/*
struct capi_appl *ap;
int i;
int len = 0;
- off_t begin = 0;
for (i=0; i < CAPI_MAXAPPL; i++) {
ap = &applications[i];
ap->nrecvdatapkt,
ap->nsentctlpkt,
ap->nsentdatapkt);
- if (len+begin > off+count)
- goto endloop;
- if (len+begin < off) {
- begin += len;
+ if (len <= off) {
+ off -= len;
len = 0;
+ } else {
+ if (len-off > count)
+ goto endloop;
}
}
endloop:
- if (i >= CAPI_MAXAPPL)
+ *start = page+off;
+ if (len < count)
*eof = 1;
- if (off >= len+begin)
- return 0;
- *start = page + (off-begin);
- return ((count < begin+len-off) ? count : begin+len-off);
+ if (len>count) len = count;
+ if (len<0) len = 0;
+ return len;
}
/*
struct capi_ctr *cp;
int i;
int len = 0;
- off_t begin = 0;
for (i=0; i < CAPI_MAXCONTR; i++) {
cp = &cards[i];
cp->nrecvdatapkt,
cp->nsentctlpkt,
cp->nsentdatapkt);
- if (len+begin > off+count)
- goto endloop;
- if (len+begin < off) {
- begin += len;
+ if (len <= off) {
+ off -= len;
len = 0;
+ } else {
+ if (len-off > count)
+ goto endloop;
}
}
endloop:
- if (i >= CAPI_MAXCONTR)
+ *start = page+off;
+ if (len < count)
*eof = 1;
- if (off >= len+begin)
- return 0;
- *start = page + (off-begin);
- return ((count < begin+len-off) ? count : begin+len-off);
+ if (len>count) len = count;
+ if (len<0) len = 0;
+ return len;
}
static struct procfsentries {
/*
- * $Id: t1isa.c,v 1.16 2000/11/23 20:45:14 kai Exp $
+ * $Id: t1isa.c,v 1.16.6.1 2001/02/13 11:43:29 kai Exp $
*
* Module for AVM T1 HEMA-card.
*
* (c) Copyright 1999 by Carsten Paeth (calle@calle.in-berlin.de)
*
* $Log: t1isa.c,v $
+ * Revision 1.16.6.1 2001/02/13 11:43:29 kai
+ * more compatility changes for 2.2.19
+ *
* Revision 1.16 2000/11/23 20:45:14 kai
* fixed module_init/exit stuff
* Note: compiled-in kernel doesn't work pre 2.2.18 anymore.
#include "capilli.h"
#include "avmcard.h"
-static char *revision = "$Revision: 1.16 $";
+static char *revision = "$Revision: 1.16.6.1 $";
/* ------------------------------------------------------------- */
/*
- * $Id: t1pci.c,v 1.13.6.1 2000/11/28 12:02:45 kai Exp $
+ * $Id: t1pci.c,v 1.13.6.2 2001/02/13 11:43:29 kai Exp $
*
* Module for AVM T1 PCI-card.
*
* (c) Copyright 1999 by Carsten Paeth (calle@calle.in-berlin.de)
*
* $Log: t1pci.c,v $
+ * Revision 1.13.6.2 2001/02/13 11:43:29 kai
+ * more compatility changes for 2.2.19
+ *
* Revision 1.13.6.1 2000/11/28 12:02:45 kai
* MODULE_DEVICE_TABLE for 2.4
*
#include "capilli.h"
#include "avmcard.h"
-static char *revision = "$Revision: 1.13.6.1 $";
+static char *revision = "$Revision: 1.13.6.2 $";
#undef CONFIG_T1PCI_DEBUG
#undef CONFIG_T1PCI_POLLDEBUG
param.irq = dev->irq;
param.membase = dev->base_address[ 0] & PCI_BASE_ADDRESS_MEM_MASK;
- retval = pci_enable_device (dev);
- if (retval != 0) {
- printk(KERN_ERR
- "%s: failed to enable AVM-T1-PCI at i/o %#x, irq %d, mem %#x err=%d\n",
- driver->name, param.port, param.irq, param.membase, retval);
- MOD_DEC_USE_COUNT;
- return -EIO;
- }
printk(KERN_INFO
"%s: PCI BIOS reports AVM-T1-PCI at i/o %#x, irq %d, mem %#x\n",
printk(KERN_ERR
"%s: no AVM-T1-PCI at i/o %#x, irq %d detected, mem %#x\n",
driver->name, param.port, param.irq, param.membase);
+ detach_capi_driver(&t1pci_driver);
MOD_DEC_USE_COUNT;
return retval;
}
return 0;
}
printk(KERN_ERR "%s: NO T1-PCI card detected\n", driver->name);
+ detach_capi_driver(&t1pci_driver);
MOD_DEC_USE_COUNT;
return -ESRCH;
#else
-/* $Id: config.c,v 2.57.6.8 2001/01/23 17:45:02 kai Exp $
+/* $Id: config.c,v 2.57.6.9 2001/02/13 10:33:58 kai Exp $
+ *
* Author Karsten Keil (keil@isdn4linux.de)
* based on the teles driver from Jan den Ouden
*
#ifdef CONFIG_ISDN_AUDIO
#include "isdn_audio.h"
#endif
+#ifdef CONFIG_ISDN_DIVERSION_MODULE
+#define CONFIG_ISDN_DIVERSION
+#endif
#ifdef CONFIG_ISDN_DIVERSION
#include <linux/isdn_divertif.h>
#endif CONFIG_ISDN_DIVERSION
isdn_dev *dev;
-static char *isdn_revision = "$Revision: 1.113 $";
+static char *isdn_revision = "$Revision: 1.114.6.7 $";
extern char *isdn_net_revision;
extern char *isdn_tty_revision;
isdn_free_queue(&dev->drv[di]->rpqueue[i]);
kfree(dev->drv[di]->rpqueue);
kfree(dev->drv[di]->rcv_waitq);
- kfree(dev->drv[di]->snd_waitq);
kfree(dev->drv[di]);
dev->drv[di] = NULL;
dev->drvid[di][0] = '\0';
}
#endif
retval = -ENODEV;
-out:
+ out:
return retval;
}
return ret;
}
-int
-register_isdn_module(isdn_module *m) {
- return 0;
-}
-
-int
-unregister_isdn_module(isdn_module *m) {
- return 0;
-}
-
int
isdn_add_channels(driver *d, int drvidx, int n, int adding)
{
int j, k, m;
ulong flags;
- init_waitqueue_head(&d->st_waitq);
+ init_waitqueue_head(&d->st_waitq);
if (d->flags & DRV_FLAG_RUNNING)
return -1;
if (n < 1) return 0;
EXPORT_SYMBOL(register_isdn);
-EXPORT_SYMBOL(register_isdn_module);
-EXPORT_SYMBOL(unregister_isdn_module);
#ifdef CONFIG_ISDN_PPP
EXPORT_SYMBOL(isdn_ppp_register_compressor);
EXPORT_SYMBOL(isdn_ppp_unregister_compressor);
#include <net/dst.h>
#include <net/pkt_sched.h>
#include <linux/inetdevice.h>
+#include <linux/isdn_compat.h>
#include "isdn_common.h"
#include "isdn_net.h"
#ifdef CONFIG_ISDN_PPP
-/* $Id: isdn_ppp.c,v 1.85 2000/11/25 17:00:59 kai Exp $
+/* $Id: isdn_ppp.c,v 1.85.6.2 2001/01/23 17:45:02 kai Exp $
*
* Linux ISDN subsystem, functions for synchronous PPP (linklevel).
*
#include <linux/poll.h>
#include <linux/isdn.h>
#include <linux/ppp-comp.h>
+#include <linux/isdn_compat.h>
#include "isdn_common.h"
#include "isdn_ppp.h"
static int isdn_ppp_if_get_unit(char *namebuf);
static int isdn_ppp_set_compressor(struct ippp_struct *is,struct isdn_ppp_comp_data *);
static struct sk_buff *isdn_ppp_decompress(struct sk_buff *,
- struct ippp_struct *,struct ippp_struct *,int proto);
+ struct ippp_struct *,struct ippp_struct *,int *proto);
static void isdn_ppp_receive_ccp(isdn_net_dev * net_dev, isdn_net_local * lp,
struct sk_buff *skb,int proto);
static struct sk_buff *isdn_ppp_compress(struct sk_buff *skb_in,int *proto,
static int isdn_ppp_bundle(struct ippp_struct *, int unit);
#endif /* CONFIG_ISDN_MPP */
-char *isdn_ppp_revision = "$Revision: 1.85 $";
+char *isdn_ppp_revision = "$Revision: 1.85.6.2 $";
static struct ippp_struct *ippp_table[ISDN_MAX_CHANNELS];
ippp_table[lp->ppp_slot]->state = IPPP_OPEN | IPPP_CONNECT | IPPP_NOBLOCK;
- wake_up_interruptible(&ippp_table[lp->ppp_slot]->wq);
+ wake_up_interruptible(&ippp_table[lp->ppp_slot]->wq);
}
/*
is->last = bl->next;
restore_flags(flags);
- wake_up_interruptible(&is->wq);
+ wake_up_interruptible(&is->wq);
return len;
}
}
+/*
+ * check for address/control field and skip if allowed
+ * retval != 0 -> discard packet silently
+ */
+static int isdn_ppp_skip_ac(struct ippp_struct *is, struct sk_buff *skb)
+{
+ if (skb->len < 1)
+ return -1;
+
+ if (skb->data[0] == 0xff) {
+ if (skb->len < 2)
+ return -1;
+
+ if (skb->data[1] != 0x03)
+ return -1;
+
+ // skip address/control (AC) field
+ skb_pull(skb, 2);
+ } else {
+ if (is->pppcfg & SC_REJ_COMP_AC)
+ // if AC compression was not negotiated, but used, discard packet
+ return -1;
+ }
+ return 0;
+}
+
/*
* get the PPP protocol header and pull skb
+ * retval < 0 -> discard packet silently
*/
static int isdn_ppp_strip_proto(struct sk_buff *skb)
{
int proto;
+
+ if (skb->len < 1)
+ return -1;
+
if (skb->data[0] & 0x1) {
+ // protocol field is compressed
proto = skb->data[0];
- skb_pull(skb, 1); /* protocol ID is only 8 bit */
+ skb_pull(skb, 1);
} else {
+ if (skb->len < 2)
+ return -1;
proto = ((int) skb->data[0] << 8) + skb->data[1];
skb_pull(skb, 2);
}
int slot;
int proto;
+ if (net_dev->local->master)
+ BUG(); // we're called with the master device always
+
slot = lp->ppp_slot;
if (slot < 0 || slot > ISDN_MAX_CHANNELS) {
printk(KERN_ERR "isdn_ppp_receive: lp->ppp_slot %d\n", lp->ppp_slot);
(long)is,(long)lp,lp->ppp_slot,is->unit,(int) skb->len);
isdn_ppp_frame_log("receive", skb->data, skb->len, 32,is->unit,lp->ppp_slot);
}
- if (net_dev->local->master) {
- printk(KERN_WARNING "isdn_ppp_receive: net_dev != master\n");
- net_dev = ((isdn_net_local *) net_dev->local->master->priv)->netdev;
- }
- if (skb->data[0] == 0xff && skb->data[1] == 0x03)
- skb_pull(skb, 2);
- else if (is->pppcfg & SC_REJ_COMP_AC) {
- dev_kfree_skb(skb);
- return; /* discard it silently */
- }
-
- proto = isdn_ppp_strip_proto(skb);
+ if (isdn_ppp_skip_ac(is, skb) < 0) {
+ kfree_skb(skb);
+ return;
+ }
+ proto = isdn_ppp_strip_proto(skb);
+ if (proto < 0) {
+ kfree_skb(skb);
+ return;
+ }
+
#ifdef CONFIG_ISDN_MPP
- if (!(is->mpppcfg & SC_REJ_MP_PROT)) {
-
- if(is->compflags & SC_LINK_DECOMP_ON) {
- if(proto == PPP_COMPFRAG) {
- if(is->debug & 0x10)
- printk(KERN_DEBUG "received single link compressed frame\n");
- skb = isdn_ppp_decompress(skb,is,NULL,proto);
- if(!skb) {
- printk(KERN_DEBUG "ippp: dropping LINK_COMP frame!\n");
- return;
- }
- proto = isdn_ppp_strip_proto(skb);
- } else {
- skb = isdn_ppp_decompress(skb,is,NULL,proto);
- if(!skb) {
- printk(KERN_DEBUG "ippp: dropping uncompressed frame!\n");
- return;
- }
- }
- }
-
- if (proto == PPP_MP) {
- isdn_ppp_mp_receive(net_dev, lp, skb);
- }
- else
- isdn_ppp_push_higher(net_dev, lp, skb, proto);
- } else
-#endif /* CONFIG_ISDN_MPP */
- isdn_ppp_push_higher(net_dev, lp, skb, proto);
+ if (is->compflags & SC_LINK_DECOMP_ON) {
+ skb = isdn_ppp_decompress(skb, is, NULL, &proto);
+ if (!skb) // decompression error
+ return;
+ }
+
+ if (!(is->mpppcfg & SC_REJ_MP_PROT)) { // we agreed to receive MPPP
+ if (proto == PPP_MP) {
+ isdn_ppp_mp_receive(net_dev, lp, skb);
+ return;
+ }
+ }
+#endif
+ isdn_ppp_push_higher(net_dev, lp, skb, proto);
}
/*
- * push frame to higher layers
+ * we receive a reassembled frame, MPPP has been taken care of before.
+ * address/control and protocol have been stripped from the skb
* note: net_dev has to be master net_dev
*/
static void
isdn_ppp_push_higher(isdn_net_dev * net_dev, isdn_net_local * lp, struct sk_buff *skb, int proto)
{
struct device *dev = &net_dev->dev;
- struct ippp_struct *is;
+ struct ippp_struct *is, *mis;
int slot;
slot = lp->ppp_slot;
if (slot < 0 || slot > ISDN_MAX_CHANNELS) {
printk(KERN_ERR "isdn_ppp_push_higher: lp->ppp_slot %d\n", lp->ppp_slot);
- kfree_skb(skb);
- return;
+ goto drop_packet;
}
is = ippp_table[slot];
+
+ if (lp->master) { // FIXME?
+ slot = ((isdn_net_local *) (lp->master->priv))->ppp_slot;
+ if (slot < 0 || slot > ISDN_MAX_CHANNELS) {
+ printk(KERN_ERR "isdn_ppp_push_higher: master->ppp_slot %d\n", lp->ppp_slot);
+ goto drop_packet;
+ }
+ }
+ mis = ippp_table[slot];
+
if (is->debug & 0x10) {
printk(KERN_DEBUG "push, skb %d %04x\n", (int) skb->len, proto);
isdn_ppp_frame_log("rpush", skb->data, skb->len, 32,is->unit,lp->ppp_slot);
}
-
- if(proto == PPP_COMP) {
- if(!lp->master) {
- skb = isdn_ppp_decompress(skb,is,is,proto);
- } else {
- skb = isdn_ppp_decompress(skb,is,ippp_table[((isdn_net_local *) (lp->master->priv))->ppp_slot],proto);
- }
- if(!skb) {
- printk(KERN_DEBUG "ippp: compressed frame discarded!\n");
- return;
- }
-
- proto = isdn_ppp_strip_proto(skb);
- if (is->debug & 0x10) {
- printk(KERN_DEBUG "RPostDecomp, skb %d %04x\n", (int) skb->len, proto);
- isdn_ppp_frame_log("R-Decomp", skb->data, skb->len, 32,is->unit,lp->ppp_slot);
- }
- }
- else if (is->compflags & SC_DECOMP_ON) { /* If decomp is ON */
- if(!lp->master) {
- skb = isdn_ppp_decompress(skb,is,is,proto);
- } else {
- skb = isdn_ppp_decompress(skb,is,ippp_table[((isdn_net_local *) (lp->master->priv))->ppp_slot],proto);
- }
-
- if(!skb) {
- printk(KERN_DEBUG "ippp: compressed frame discarded!\n");
- return;
- }
- }
-
+ if (is->compflags & SC_DECOMP_ON) {
+ skb = isdn_ppp_decompress(skb, is, mis, &proto);
+ if (!skb) // decompression error
+ return;
+ }
switch (proto) {
case PPP_IPX: /* untested */
if (is->debug & 0x20)
printk(KERN_DEBUG "isdn_ppp: IPX\n");
- skb->dev = dev;
- skb->mac.raw = skb->data;
skb->protocol = htons(ETH_P_IPX);
break;
+ case PPP_IP:
+ if (is->debug & 0x20)
+ printk(KERN_DEBUG "isdn_ppp: IP\n");
+ skb->protocol = htons(ETH_P_IP);
+ break;
#ifdef CONFIG_ISDN_PPP_VJ
case PPP_VJC_UNCOMP:
if (is->debug & 0x20)
printk(KERN_DEBUG "isdn_ppp: VJC_UNCOMP\n");
if (slhc_remember(ippp_table[net_dev->local->ppp_slot]->slcomp, skb->data, skb->len) <= 0) {
printk(KERN_WARNING "isdn_ppp: received illegal VJC_UNCOMP frame!\n");
- net_dev->local->stats.rx_dropped++;
- dev_kfree_skb(skb);
- return;
+ goto drop_packet;
}
-#endif
- case PPP_IP:
- if (is->debug & 0x20)
- printk(KERN_DEBUG "isdn_ppp: IP\n");
- skb->dev = dev;
- skb->mac.raw = skb->data;
skb->protocol = htons(ETH_P_IP);
break;
case PPP_VJC_COMP:
if (is->debug & 0x20)
printk(KERN_DEBUG "isdn_ppp: VJC_COMP\n");
-#ifdef CONFIG_ISDN_PPP_VJ
{
struct sk_buff *skb_old = skb;
int pkt_len;
if (!skb) {
printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
- net_dev->local->stats.rx_dropped++;
- dev_kfree_skb(skb_old);
- return;
+ skb = skb_old;
+ goto drop_packet;
}
- skb->dev = dev;
skb_put(skb, skb_old->len + 128);
memcpy(skb->data, skb_old->data, skb_old->len);
- skb->mac.raw = skb->data;
pkt_len = slhc_uncompress(ippp_table[net_dev->local->ppp_slot]->slcomp,
skb->data, skb_old->len);
- dev_kfree_skb(skb_old);
- if (pkt_len < 0) {
- dev_kfree_skb(skb);
- lp->stats.rx_dropped++;
- return;
- }
+ kfree_skb(skb_old);
+ if (pkt_len < 0)
+ goto drop_packet;
+
skb_trim(skb, pkt_len);
skb->protocol = htons(ETH_P_IP);
}
-#else
- printk(KERN_INFO "isdn: Ooopsa .. VJ-Compression support not compiled into isdn driver.\n");
- lp->stats.rx_dropped++;
- dev_kfree_skb(skb);
- return;
-#endif
break;
+#endif
case PPP_CCP:
case PPP_CCPFRAG:
isdn_ppp_receive_ccp(net_dev,lp,skb,proto);
/* fall through */
default:
isdn_ppp_fill_rq(skb->data, skb->len, proto, lp->ppp_slot); /* push data to pppd device */
- dev_kfree_skb(skb);
+ kfree_skb(skb);
return;
}
/* Reset hangup-timer */
lp->huptimer = 0;
- netif_rx(skb);
- /* net_dev->local->stats.rx_packets++; *//* done in isdn_net.c */
+ skb->dev = dev;
+ skb->mac.raw = skb->data;
+ netif_rx(skb);
+ /* net_dev->local->stats.rx_packets++; done in isdn_net.c */
return;
+
+ drop_packet:
+ net_dev->local->stats.rx_dropped++;
+ kfree_skb(skb);
}
/*
* isdn_ppp_skb_push ..
- * checks whether we have enough space at the beginning of the SKB
+ * checks whether we have enough space at the beginning of the skb
* and allocs a new SKB if necessary
*/
static unsigned char *isdn_ppp_skb_push(struct sk_buff **skb_p,int len)
static u32 isdn_ppp_mp_get_seq( int short_seq,
struct sk_buff * skb, u32 last_seq );
-struct sk_buff * isdn_ppp_mp_discard( ippp_bundle * mp,
+static struct sk_buff * isdn_ppp_mp_discard( ippp_bundle * mp,
struct sk_buff * from, struct sk_buff * to );
-void isdn_ppp_mp_reassembly( isdn_net_dev * net_dev, isdn_net_local * lp,
+static void isdn_ppp_mp_reassembly( isdn_net_dev * net_dev, isdn_net_local * lp,
struct sk_buff * from, struct sk_buff * to );
static void isdn_ppp_mp_free_skb( ippp_bundle * mp, struct sk_buff * skb );
static void isdn_ppp_mp_print_recv_pkt( int slot, struct sk_buff * skb );
is->reset->lastid++;
}
+/*
+ * decompress packet
+ *
+ * if master = 0, we're trying to uncompress an per-link compressed packet,
+ * as opposed to an compressed reconstructed-from-MPPP packet.
+ * proto is updated to protocol field of uncompressed packet.
+ *
+ * retval: decompressed packet,
+ * same packet if uncompressed,
+ * NULL if decompression error
+ */
+
static struct sk_buff *isdn_ppp_decompress(struct sk_buff *skb,struct ippp_struct *is,struct ippp_struct *master,
- int proto)
+ int *proto)
{
void *stat = NULL;
struct isdn_ppp_compressor *ipc = NULL;
unsigned char rsdata[IPPP_RESET_MAXDATABYTES];
if(!master) {
- /*
- * single link decompression
- */
- if(!is->link_decompressor) {
- printk(KERN_DEBUG "ippp: no link decompressor defined!\n");
- return skb;
- }
- if(!is->link_decomp_stat) {
- printk(KERN_DEBUG "ippp: no link decompressor data allocated\n");
- return skb;
- }
+ // per-link decompression
stat = is->link_decomp_stat;
ipc = is->link_decompressor;
ri = is;
- }
- else {
- /*
- * 'normal' or bundle-compression
- */
- if(!master->decompressor) {
- printk(KERN_DEBUG "ippp: no decompressor defined!\n");
- return skb;
- }
- if(!master->decomp_stat) {
- printk(KERN_DEBUG "ippp: no decompressor data allocated\n");
- return skb;
- }
+ } else {
stat = master->decomp_stat;
ipc = master->decompressor;
ri = master;
}
- /*
- printk(KERN_DEBUG "ippp: Decompress valid!\n");
- */
+ if (!ipc) {
+ // no decompressor -> we can't decompress.
+ printk(KERN_DEBUG "ippp: no decompressor defined!\n");
+ return skb;
+ }
+ if (!stat) // if we have a compressor, stat has been set as well
+ BUG();
- if((master && proto == PPP_COMP) || (!master && proto == PPP_COMPFRAG) ) {
- /* Set up reset params for the decompressor */
- memset(&rsparm, 0, sizeof(rsparm));
- rsparm.data = rsdata;
- rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
+ if((master && *proto == PPP_COMP) || (!master && *proto == PPP_COMPFRAG) ) {
+ // compressed packets are compressed by their protocol type
-/* !!!HACK,HACK,HACK!!! 2048 is only assumed */
- skb_out = dev_alloc_skb(2048);
- len = ipc->decompress(stat,skb,skb_out, &rsparm);
- dev_kfree_skb(skb);
- if(len <= 0) {
- /* Ok, some error */
- switch(len) {
- case DECOMP_ERROR:
- ri->pppcfg |= SC_DC_ERROR;
- printk(KERN_INFO "ippp: decomp wants reset %s params\n",
- rsparm.valid ? "with" : "without");
-
- isdn_ppp_ccp_reset_trans(ri, &rsparm);
-
- break;
- case DECOMP_FATALERROR:
- ri->pppcfg |= SC_DC_FERROR;
- /* Kick ipppd to recognize the error */
- isdn_ppp_ccp_kickup(ri);
- break;
- }
- /* Did I see a leak here ? */
- dev_kfree_skb(skb_out);
- return NULL;
+ // Set up reset params for the decompressor
+ memset(&rsparm, 0, sizeof(rsparm));
+ rsparm.data = rsdata;
+ rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
+
+ skb_out = dev_alloc_skb(is->mru + PPP_HDRLEN);
+ len = ipc->decompress(stat, skb, skb_out, &rsparm);
+ kfree_skb(skb);
+ if (len <= 0) {
+ switch(len) {
+ case DECOMP_ERROR:
+ ri->pppcfg |= SC_DC_ERROR;
+ printk(KERN_INFO "ippp: decomp wants reset %s params\n",
+ rsparm.valid ? "with" : "without");
+
+ isdn_ppp_ccp_reset_trans(ri, &rsparm);
+ break;
+ case DECOMP_FATALERROR:
+ ri->pppcfg |= SC_DC_FERROR;
+ /* Kick ipppd to recognize the error */
+ isdn_ppp_ccp_kickup(ri);
+ break;
+ }
+ kfree_skb(skb_out);
+ return NULL;
+ }
+ *proto = isdn_ppp_strip_proto(skb_out);
+ if (*proto < 0) {
+ kfree_skb(skb_out);
+ return NULL;
}
return skb_out;
- }
- else {
- /*
- printk(KERN_DEBUG "isdn_ppp: [%d] Calling incomp with this frame!\n",is->unit);
- */
- ipc->incomp(stat,skb,proto);
+ } else {
+ // uncompressed packets are fed through the decompressor to
+ // update the decompressor state
+ ipc->incomp(stat, skb, *proto);
return skb;
}
}
#endif /* STRICT_MM_TYPECHECKS */
#endif /* !ASSEMBLY */
+#if !defined(BUG)
+#define BUG() __asm__ __volatile__("call_pal 129 # bugchk")
+#endif
+
/* to align the pointer to the (next) page boundary */
#define PAGE_ALIGN(addr) (((addr)+PAGE_SIZE-1)&PAGE_MASK)
#include <asm/io.h>
#include <linux/kernel.h>
#include <linux/signal.h>
-#include <linux/malloc.h>
+#include <linux/slab.h>
#include <linux/timer.h>
#include <linux/wait.h>
#include <linux/tty.h>
typedef struct isdn_net_local_s {
ulong magic;
char name[10]; /* Name of device */
- struct enet_statistics stats; /* Ethernet Statistics */
+ struct net_device_stats stats; /* Ethernet Statistics */
int isdn_device; /* Index to isdn-device */
int isdn_channel; /* Index to isdn-channel */
int ppp_slot; /* PPPD device slot number */
char *private;
} infostruct;
-typedef struct isdn_module {
- struct isdn_module *prev;
- struct isdn_module *next;
- char *name;
- int (*get_free_channel)(int, int, int, int, int);
- int (*free_channel)(int, int, int);
- int (*status_callback)(isdn_ctrl *);
- int (*command)(isdn_ctrl *);
- int (*receive_callback)(int, int, struct sk_buff *);
- int (*writebuf_skb)(int, int, int, struct sk_buff *);
- int (*net_start_xmit)(struct sk_buff *, struct device *);
- int (*net_receive)(struct device *, struct sk_buff *);
- int (*net_open)(struct device *);
- int (*net_close)(struct device *);
- int priority;
-} isdn_module;
-
#define DRV_FLAG_RUNNING 1
#define DRV_FLAG_REJBUS 2
#define DRV_FLAG_LOADED 4
ulong flags; /* Misc driver Flags */
int locks; /* Number of locks for this driver */
int channels; /* Number of channels */
- struct wait_queue *st_waitq; /* Wait-Queue for status-read's */
+ wait_queue_head_t st_waitq; /* Wait-Queue for status-read's */
int maxbufsize; /* Maximum Buffersize supported */
unsigned long pktcount; /* Until now: unused */
int stavail; /* Chars avail on Status-device */
unsigned long DLEflag; /* Flags: Insert DLE at next read */
#endif
struct sk_buff_head *rpqueue; /* Pointers to start of Rcv-Queue */
- struct wait_queue **rcv_waitq; /* Wait-Queues for B-Channel-Reads */
- struct wait_queue **snd_waitq; /* Wait-Queue for B-Channel-Send's */
+ wait_queue_head_t *rcv_waitq; /* Wait-Queues for B-Channel-Reads */
+ wait_queue_head_t *snd_waitq; /* Wait-Queue for B-Channel-Send's */
char msn2eaz[10][ISDN_MSNLEN]; /* Mapping-Table MSN->EAZ */
} driver;
/* see ISDN_TIMER_..defines */
int global_flags;
infostruct *infochain; /* List of open info-devs. */
- struct wait_queue *info_waitq; /* Wait-Queue for isdninfo */
+ wait_queue_head_t info_waitq; /* Wait-Queue for isdninfo */
struct timer_list timer; /* Misc.-function Timer */
int chanmap[ISDN_MAX_CHANNELS];/* Map minor->device-channel */
int drvmap[ISDN_MAX_CHANNELS]; /* Map minor->driver-index */
atomic_t v110use[ISDN_MAX_CHANNELS];/* Usage-Semaphore for stream */
isdn_v110_stream *v110[ISDN_MAX_CHANNELS]; /* V.110 private data */
struct semaphore sem; /* serialize list access*/
- isdn_module *modules;
unsigned long global_features;
} isdn_dev;
extern isdn_dev *dev;
-
/* Utility-Macros */
#define MIN(a,b) ((a<b)?a:b)
#define MAX(a,b) ((a>b)?a:b)
-/*
- * Tell upper layers that the network device is ready to xmit more frames.
- */
-static void __inline__ netif_wake_queue(struct device * dev)
-{
- dev->tbusy = 0;
- mark_bh(NET_BH);
-}
-
-/*
- * called during net_device open()
- */
-static void __inline__ netif_start_queue(struct device * dev)
-{
- dev->tbusy = 0;
- /* actually, we never use the interrupt flag at all */
- dev->interrupt = 0;
- dev->start = 1;
-}
-
-/*
- * Ask upper layers to temporarily cease passing us more xmit frames.
- */
-static void __inline__ netif_stop_queue(struct device * dev)
-{
- dev->tbusy = 1;
-}
-
-struct pci_dev;
-
-static int __inline__ pci_enable_device(struct pci_dev * pdev)
-{
- return 0;
-}
-
#endif /* __KERNEL__ */
#endif /* isdn_h */
return NULL;
}
+#include <linux/netdevice.h>
+
+/*
+ * Tell upper layers that the network device is ready to xmit more frames.
+ */
+static void __inline__ netif_wake_queue(struct device * dev)
+{
+ dev->tbusy = 0;
+ mark_bh(NET_BH);
+}
+
+/*
+ * called during net_device open()
+ */
+static void __inline__ netif_start_queue(struct device * dev)
+{
+ dev->tbusy = 0;
+ /* actually, we never use the interrupt flag at all */
+ dev->interrupt = 0;
+ dev->start = 1;
+}
+
+/*
+ * Ask upper layers to temporarily cease passing us more xmit frames.
+ */
+static void __inline__ netif_stop_queue(struct device * dev)
+{
+ dev->tbusy = 1;
+}
+
+
+
+
#endif /* __KERNEL__ */
#endif /* _LINUX_ISDN_COMPAT_H */
/*
- * $Id: kernelcapi.h,v 1.8.6.1 2000/11/28 09:36:56 kai Exp $
+ * $Id: kernelcapi.h,v 1.8.6.2 2001/02/07 11:31:31 kai Exp $
*
* Kernel CAPI 2.0 Interface for Linux
*
#ifndef __KERNELCAPI_H__
#define __KERNELCAPI_H__
-#define CAPI_MAXAPPL 20 /* maximum number of applications */
-#define CAPI_MAXCONTR 10 /* maximum number of controller */
+#define CAPI_MAXAPPL 128 /* maximum number of applications */
+#define CAPI_MAXCONTR 16 /* maximum number of controller */
#define CAPI_MAXDATAWINDOW 8
# differ on your system.
#
PATH=/sbin:/usr/sbin:/bin:/usr/bin:$PATH
-echo '-- Versions installed: (if some fields are empty or looks'
-echo '-- unusual then possibly you have very old versions)'
+echo 'If some fields are empty or look unusual you may have an old version.'
+echo 'Compare to the current minimal requirements in Documentation/Changes.'
+echo ' '
+
uname -a
-insmod -V 2>&1 | awk 'NR==1 {print "Kernel modules ",$NF}'
+echo ' '
+
echo "Gnu C " `gcc --version`
+
+make --version 2>&1 | awk -F, '{print $1}' | awk \
+ '/GNU Make/{print "Gnu make ",$NF}'
+
ld -v 2>&1 | awk -F\) '{print $1}' | awk \
- '/BFD/{print "Binutils ",$NF}'
-ls -l `ldd /bin/sh | awk '/libc/{print $3}'` | sed -e 's/\.so$//' \
- | awk -F'[.-]' '{print "Linux C Library " $(NF-2)"."$(NF-1)"."$NF}'
-echo -n "Dynamic linker "
-ldd -v > /dev/null 2>&1 && ldd -v || ldd --version |head -1
+ '/BFD/{print "binutils ",$NF}'
+
+mount --version | awk -F\- '{print "util-linux ", $NF}'
+
+insmod -V 2>&1 | awk 'NR==1 {print "modutils ",$NF}'
+
+tune2fs 2>&1 | grep tune2fs | sed 's/,//' | awk \
+'NR==1 {print "e2fsprogs ", $2}'
+
+reiserfsck 2>&1 | grep reiserfsprogs | awk \
+'NR==1{print "reiserfsprogs ", $NF}'
+
+cardmgr -V 2>&1| grep version | awk \
+'NR==1{print "pcmcia-cs ", $3}'
+
+pppd --version 2>&1| grep version | awk \
+'NR==1{print "PPP ", $3}'
+
+isdnctrl 2>&1 | grep version | awk \
+'NR==1{print "isdn4k-utils ", $NF}'
+
+ls -l `ldd /bin/sh | awk '/libc/{print $3}'` | sed \
+-e 's/\.so$//' | awk -F'[.-]' '{print "Linux C Library " \
+$(NF-2)"."$(NF-1)"."$NF}'
+
+ldd -v > /dev/null 2>&1 && ldd -v || ldd --version |head -1 | awk \
+'NR==1{print "Dynamic linker (ldd) ", $NF}'
+
ls -l /usr/lib/lib{g,stdc}++.so 2>/dev/null | awk -F. \
'{print "Linux C++ Library " $4"."$5"."$6}'
+
ps --version 2>&1 | awk 'NR==1{print "Procps ", $NF}'
-mount --version | awk -F\- '{print "Mount ", $NF}'
-hostname -V 2>&1 | awk 'NR==1{print "Net-tools ", $NF}'
+
+ifconfig --version 2>&1 | grep tools | awk \
+'NR==1{print "Net-tools ", $NF}'
+
# Kbd needs 'loadkeys -h',
loadkeys -h 2>&1 | awk \
'(NR==1 && ($3 !~ /option/)) {print "Kbd ", $3}'
+
# while console-tools needs 'loadkeys -V'.
loadkeys -V 2>&1 | awk \
'(NR==1 && ($2 ~ /console-tools/)) {print "Console-tools ", $3}'
-expr --v | awk 'NR==1{print "Sh-utils ", $NF}'
+
+expr --v 2>&1 | awk 'NR==1{print "Sh-utils ", $NF}'
+
X=`cat /proc/modules | sed -e "s/ .*$//"`
echo "Modules Loaded "$X
projects / history.git / commitdiff