amcc_orig.cpp

The PCI Local bus concept was developed to break the PC data I/O bottleneck and clearly opens the d

	if(params[SI_PASSTHROUGH_OFFSET_INDEX] > (pdx->base_len[params[SI_PASSTHROUGH_REGION_INDEX]]) ) 
		 return STATUS_INVALID_PARAMETER_2;

	// check for null base pointer
	if(pdx->base[params[SI_PASSTHROUGH_REGION_INDEX]] == NULL)
		return STATUS_INVALID_PARAMETER_1;

	bytePointer = (CHAR *) pdx->base[params[SI_PASSTHROUGH_REGION_INDEX]];
	bytePointer += params[SI_PASSTHROUGH_OFFSET_INDEX];

	// write number of bytes coming back, before this param is overwritten
	Irp->IoStatus.Information = params[SI_PASSTHROUGH_COUNT_INDEX] * sizeof(ULONG);

/////////////////
// IO and memory mapped
/////////////////
	// all looks OK, so do the read
	if( (ULONG)bytePointer & 0xffff0000 )
		READ_REGISTER_BUFFER_ULONG((PULONG) bytePointer,
			(PULONG) Irp->AssociatedIrp.SystemBuffer,
			params[SI_PASSTHROUGH_COUNT_INDEX]);
	else
		READ_PORT_BUFFER_ULONG((PULONG) bytePointer,
			(PULONG) Irp->AssociatedIrp.SystemBuffer,
			params[SI_PASSTHROUGH_COUNT_INDEX]);

/////////////////
// Memory mapped Only
/////////////////
//	READ_REGISTER_BUFFER_ULONG((PULONG) bytePointer,
//		(PULONG) Irp->AssociatedIrp.SystemBuffer,
//		params[SI_PASSTHROUGH_COUNT_INDEX]);

	return STATUS_SUCCESS;			
}

/*

Function Name:

	SheldonPassthroughWrite

Routine Description:

    Write to the Passthrough region.

Arguments:

	Irp - I/O request being serviced

	pdx - pointer to the device extension.

Return Value:

    STATUS_SUCCESS

*/	
NTSTATUS SheldonPassthroughWrite(PIRP Irp, PDEVICE_EXTENSION pdx)
{
	PULONG params;
	CHAR *bytePointer; 

	// get a ULONG pointer to the buffer
	params = (PULONG) Irp->AssociatedIrp.SystemBuffer;
	
	// check that the passthrough region given really is a passthrough region
	if(params[SI_PASSTHROUGH_REGION_INDEX] > AMCC_LAST_PASS_THROUGH_REGION || params[SI_PASSTHROUGH_REGION_INDEX] < AMCC_FIRST_PASS_THROUGH_REGION) 
		return STATUS_INVALID_PARAMETER_1;

	// check that the offset is smaller than the size of the region
	if(params[SI_PASSTHROUGH_OFFSET_INDEX] > (pdx->base_len[params[SI_PASSTHROUGH_REGION_INDEX]]) ) 
		return STATUS_INVALID_PARAMETER_2;

	// check for null base pointer
	if(pdx->base[params[SI_PASSTHROUGH_REGION_INDEX]] == NULL)
		return STATUS_INVALID_PARAMETER_1;
		
	// adjust to byte offsets
	bytePointer = (CHAR *) pdx->base[params[SI_PASSTHROUGH_REGION_INDEX]];
	bytePointer += params[SI_PASSTHROUGH_OFFSET_INDEX];

/////////////////
// IO and memory mapped
/////////////////
	// write the data
	if( (ULONG)bytePointer & 0xffff0000 )
		WRITE_REGISTER_BUFFER_ULONG((PULONG) bytePointer,
			// must skip over first parameters to get to data
			&(params[SI_PASSTHROUGH_WRITE_DATA_INDEX]),
			params[SI_PASSTHROUGH_COUNT_INDEX]);
	else
		WRITE_PORT_BUFFER_ULONG((PULONG) bytePointer,
			// must skip over first parameters to get to data
			&(params[SI_PASSTHROUGH_WRITE_DATA_INDEX]),
			params[SI_PASSTHROUGH_COUNT_INDEX]);

/////////////////
// Memory mapped Only
/////////////////
//	WRITE_REGISTER_BUFFER_ULONG((PULONG) bytePointer,
//		// must skip over first parameters to get to data
//		&(params[SI_PASSTHROUGH_WRITE_DATA_INDEX]),
//		params[SI_PASSTHROUGH_COUNT_INDEX]);

	return STATUS_SUCCESS;
}

/*

Function Name:

	SheldonPassthroughRead16

Routine Description:

    Read from the Passthrough region.

Arguments:

	Irp - I/O request being serviced

	pdx - pointer to the device extension.

Return Value:

    STATUS_SUCCESS

*/
NTSTATUS SheldonPassthroughRead16(PIRP Irp, PDEVICE_EXTENSION pdx)
{
	PULONG params;
	CHAR *bytePointer;

	// get a ULONG pointer to the buffer
	params = (PULONG) Irp->AssociatedIrp.SystemBuffer;

	// check that the passthrough region given really is a passthrough region
	if(params[SI_PASSTHROUGH_REGION_INDEX] > AMCC_LAST_PASS_THROUGH_REGION || params[SI_PASSTHROUGH_REGION_INDEX] < AMCC_FIRST_PASS_THROUGH_REGION) 
		 return STATUS_INVALID_PARAMETER_1;

	// check that the offset is smaller than the size of the region
	if(params[SI_PASSTHROUGH_OFFSET_INDEX] > pdx->base_len[params[SI_PASSTHROUGH_REGION_INDEX]] ) 
		 return STATUS_INVALID_PARAMETER_2;

	bytePointer = (CHAR *) pdx->base[params[SI_PASSTHROUGH_REGION_INDEX]];
	bytePointer += params[SI_PASSTHROUGH_OFFSET_INDEX];

	// write number of bytes coming back, before this param is overwritten
	Irp->IoStatus.Information = params[SI_PASSTHROUGH_COUNT_INDEX] * sizeof(USHORT);

/////////////////
// IO and memory mapped
/////////////////
	// read the data
	if( (ULONG)bytePointer & 0xffff0000 )
		READ_REGISTER_BUFFER_USHORT((PUSHORT) bytePointer,
			(PUSHORT) Irp->AssociatedIrp.SystemBuffer,
			params[SI_PASSTHROUGH_COUNT_INDEX]);
	else
		READ_PORT_BUFFER_USHORT((PUSHORT) bytePointer,
			(PUSHORT) Irp->AssociatedIrp.SystemBuffer,
			params[SI_PASSTHROUGH_COUNT_INDEX]);

/////////////////
// Memory mapped Only
/////////////////
//	READ_REGISTER_BUFFER_USHORT((PUSHORT) bytePointer,
//		(PUSHORT) Irp->AssociatedIrp.SystemBuffer,
//		params[SI_PASSTHROUGH_COUNT_INDEX]);

	return STATUS_SUCCESS;
}

/*

Function Name:

	SheldonPassthroughWrite16

Routine Description:

    Write to the Passthrough region.

Arguments:

	Irp - I/O request being serviced

	pdx - pointer to the device extension.

Return Value:

    STATUS_SUCCESS

*/
NTSTATUS SheldonPassthroughWrite16(PIRP Irp, PDEVICE_EXTENSION pdx)
{
	PULONG params;
	CHAR *bytePointer;

	// get a ULONG pointer to the buffer
	params = (PULONG) Irp->AssociatedIrp.SystemBuffer;
	
	// check that the passthrough region given really is a passthrough region
	if(params[SI_PASSTHROUGH_REGION_INDEX] > AMCC_LAST_PASS_THROUGH_REGION || params[SI_PASSTHROUGH_REGION_INDEX] < AMCC_FIRST_PASS_THROUGH_REGION) 
		return STATUS_INVALID_PARAMETER_1;

	// check that the offset is smaller than the size of the region
	if(params[SI_PASSTHROUGH_OFFSET_INDEX] > pdx->base_len[params[SI_PASSTHROUGH_REGION_INDEX]] ) 
		return STATUS_INVALID_PARAMETER_2;

	// adjust to byte offsets
	bytePointer = (CHAR *) pdx->base[params[SI_PASSTHROUGH_REGION_INDEX]];
	bytePointer += params[SI_PASSTHROUGH_OFFSET_INDEX];

/////////////////
// IO and memory mapped
/////////////////
	// write the data
	if( (ULONG)bytePointer & 0xffff0000 )
		WRITE_REGISTER_BUFFER_USHORT((PUSHORT) bytePointer,
			// must skip over first parameters to get to data
			(PUSHORT) &(params[SI_PASSTHROUGH_WRITE_DATA_INDEX]),
			params[SI_PASSTHROUGH_COUNT_INDEX]);
	else
		WRITE_PORT_BUFFER_USHORT((PUSHORT) bytePointer,
			// must skip over first parameters to get to data
			(PUSHORT) &(params[SI_PASSTHROUGH_WRITE_DATA_INDEX]),
			params[SI_PASSTHROUGH_COUNT_INDEX]);

/////////////////
// Memory mapped Only
/////////////////
//	WRITE_REGISTER_BUFFER_USHORT((PUSHORT) bytePointer,
//		// must skip over first parameters to get to data
//		(PUSHORT) &(params[SI_PASSTHROUGH_WRITE_DATA_INDEX]),
//		params[SI_PASSTHROUGH_COUNT_INDEX]);

	return STATUS_SUCCESS;
}

/*

Function Name:

	SheldonPassthroughRead8

Routine Description:

    Read from the Passthrough region.

Arguments:

	Irp - I/O request being serviced

	pdx - pointer to the device extension.

Return Value:

    STATUS_SUCCESS

*/
NTSTATUS SheldonPassthroughRead8(PIRP Irp, PDEVICE_EXTENSION pdx)
{
	PULONG params;
	CHAR *bytePointer;

	// get a ULONG pointer to the buffer
	params = (PULONG) Irp->AssociatedIrp.SystemBuffer;

	// check that the passthrough region given really is a passthrough region
	if(params[SI_PASSTHROUGH_REGION_INDEX] > AMCC_LAST_PASS_THROUGH_REGION || params[SI_PASSTHROUGH_REGION_INDEX] < AMCC_FIRST_PASS_THROUGH_REGION) 
		 return STATUS_INVALID_PARAMETER_1;

	// check that the offset is smaller than the size of the region
	if(params[SI_PASSTHROUGH_OFFSET_INDEX] > pdx->base_len[params[SI_PASSTHROUGH_REGION_INDEX]] ) 
		 return STATUS_INVALID_PARAMETER_2;

	bytePointer = (CHAR *) pdx->base[params[SI_PASSTHROUGH_REGION_INDEX]];
	bytePointer += params[SI_PASSTHROUGH_OFFSET_INDEX];

	//write number of bytes coming back, before this param is overwritten
	Irp->IoStatus.Information = params[SI_PASSTHROUGH_COUNT_INDEX] * sizeof(UCHAR);
	
/////////////////
// IO and memory mapped
/////////////////
	// all looks OK, so do the read
	if( (ULONG)bytePointer & 0xffff0000 )
		READ_REGISTER_BUFFER_UCHAR((PUCHAR) bytePointer,
			(PUCHAR) Irp->AssociatedIrp.SystemBuffer,
			params[SI_PASSTHROUGH_COUNT_INDEX]);
	else
		READ_PORT_BUFFER_UCHAR((PUCHAR) bytePointer,
			(PUCHAR) Irp->AssociatedIrp.SystemBuffer,
			params[SI_PASSTHROUGH_COUNT_INDEX]);

/////////////////
// Memory mapped Only
/////////////////
//	READ_REGISTER_BUFFER_UCHAR((PUCHAR) bytePointer,
//		(PUCHAR) Irp->AssociatedIrp.SystemBuffer,
//		params[SI_PASSTHROUGH_COUNT_INDEX]);

	return STATUS_SUCCESS;
}

/*

Function Name:

	SheldonPassthroughWrite8

Routine Description:

    Write to the Passthrough region.

Arguments:

	Irp - I/O request being serviced

	pdx - pointer to the device extension.

Return Value:

    STATUS_SUCCESS

*/
NTSTATUS SheldonPassthroughWrite8(PIRP Irp, PDEVICE_EXTENSION pdx)
{
	PULONG params;
	CHAR *bytePointer;

	// get a ULONG pointer to the buffer
	params = (PULONG) Irp->AssociatedIrp.SystemBuffer;
	
	// check that the passthrough region given really is a passthrough region
	if(params[SI_PASSTHROUGH_REGION_INDEX] > AMCC_LAST_PASS_THROUGH_REGION || params[SI_PASSTHROUGH_REGION_INDEX] < AMCC_FIRST_PASS_THROUGH_REGION) 
		return STATUS_INVALID_PARAMETER_1;

	// check that the offset is smaller than the size of the region
	if(params[SI_PASSTHROUGH_OFFSET_INDEX] > pdx->base_len[params[SI_PASSTHROUGH_REGION_INDEX]] ) 
		return STATUS_INVALID_PARAMETER_2;
		
	// adjust to byte offsets
	bytePointer = (CHAR *) pdx->base[params[SI_PASSTHROUGH_REGION_INDEX]];
	bytePointer += params[SI_PASSTHROUGH_OFFSET_INDEX];

/////////////////
// IO and memory mapped
/////////////////
	// write the data
	if( (ULONG)bytePointer & 0xffff0000 )
		WRITE_REGISTER_BUFFER_UCHAR((PUCHAR) bytePointer,
			// must skip over first parameters to get to data
			(PUCHAR) &(params[SI_PASSTHROUGH_WRITE_DATA_INDEX]),
			params[SI_PASSTHROUGH_COUNT_INDEX]);
	else
		WRITE_PORT_BUFFER_UCHAR((PUCHAR) bytePointer,
			// must skip over first parameters to get to data
			(PUCHAR) &(params[SI_PASSTHROUGH_WRITE_DATA_INDEX]),
			params[SI_PASSTHROUGH_COUNT_INDEX]);

/////////////////
// Memory mapped Only
/////////////////
//	WRITE_REGISTER_BUFFER_UCHAR((PUCHAR) bytePointer,
//		// must skip over first parameters to get to data
//		(PUCHAR) &(params[SI_PASSTHROUGH_WRITE_DATA_INDEX]),
//		params[SI_PASSTHROUGH_COUNT_INDEX]);

	return STATUS_SUCCESS;
}

/*

Function Name:

	SheldonFIFORead

Routine Description:

    Read from the FIFO.

Arguments:

	Irp - I/O request being serviced

	pdx - pointer to the device extension.

Return Value:

    STATUS_SUCCESS

*/
NTSTATUS SheldonFIFORead(PIRP Irp, PDEVICE_EXTENSION pdx)
{
	PULONG params;

	// get a ULONG pointer to the mailbox number
	params = (PULONG) Irp->AssociatedIrp.SystemBuffer;

/////////////////
// IO and memory mapped
/////////////////
	if( (ULONG)pdx->base[AMCC_OPREGS] & 0xffff0000 ) {
		// CRITICAL: Must check that the FIFO has data. Reading from an empty FIFO
		// will HANG the machine on AMCC 5933A and 5933B parts, maybe C as well
		// the output buffer contents is set to the value in the FIFO
		if(READ_REGISTER_ULONG(pdx->base[AMCC_OPREGS] + AMCC_MCSR) & AMCC_READ_FIFO_EMPTY_MASK)
			return STATUS_UNSUCCESSFUL;

		*params = READ_REGISTER_ULONG(pdx->base[AMCC_OPREGS] + AMCC_FIFO);
	}
	else {
		// CRITICAL: Must check that the FIFO has data. Reading from an empty FIFO
		// will HANG the machine on AMCC 5933A and 5933B parts, maybe C as well
		// the output buffer contents is set to the value in the FIFO
		if(READ_PORT_ULONG(pdx->base[AMCC_OPREGS] + AMCC_MCSR) & AMCC_READ_FIFO_EMPTY_MASK)
			return STATUS_UNSUCCESSFUL;

		*params = READ_PORT_ULONG(pdx->base[AMCC_OPREGS] + AMCC_FIFO);
	}

/////////////////
// Memory mapped Only
/////////////////
	// CRITICAL: Must check that the FIFO has data. Reading from an empty FIFO
	// will HANG the machine on AMCC 5933A and 5933B parts, maybe C as well
	// the output buffer contents is set to the value in the FIFO
//	if(READ_REGISTER_ULONG(pdx->base[AMCC_OPREGS] + AMCC_MCSR) & AMCC_READ_FIFO_EMPTY_MASK)
//		return STATUS_UNSUCCESSFUL;
//
//	*params = READ_REGISTER_ULONG(pdx->base[AMCC_OPREGS] + AMCC_FIFO);

	return STATUS_SUCCESS;
}