MICROSEQ(9) NetBSD Kernel Manual MICROSEQ(9)

NAME

microseq

ppbus microsequencer developer's guide

SYNOPSIS

#include <sys/types.h>
#include <dev/ppbus/ppbus_conf.h>
#include <dev/ppbus/ppbus_msq.h>

DESCRIPTION

See ppbus(4) for ppbus description and general info about the microsequencer.

The purpose of this document is to encourage developers to use the microsequencer mechanism in order to have:

1. a uniform programming model
2. efficient code

Before using microsequences, you are encouraged to look at atppc(4) microsequencer implementation and an example of how using it in vpo(4).

PPBUS register model

Background

The parallel port model chosen for ppbus is the PC parallel port model. Thus, any register described later has the same semantic than its counterpart in a PC parallel port. For more info about ISA/ECP programming, refer to the Microsoft standard: "Extended Capabilities Port Protocol and ISA interface Standard". Registers described later are standard parallel port registers.

Mask macros are defined in the standard ppbus include files for each valid bit of parallel port registers.

Data register

In compatible or nibble mode, writing to this register will drive data to the parallel port data lines. In any other mode, drivers may be tri-stated by setting the direction bit (PCD) in the control register. Reads to this register return the value on the data lines.

Device status register

This read-only register reflects the inputs on the parallel port interface.

Others are reserved and return undefined result when read.

Device control register

This register directly controls several output signals as well as enabling some functions.

MICROINSTRUCTIONS

Description

Microinstructions are either parallel port accesses, program iterations, sub-microsequence or C calls. The parallel port must be considered as the logical model described in ppbus(4).

Available microinstructions are: MS_OP_GET, MS_OP_PUT, MS_OP_RFETCH, MS_OP_RSET, MS_OP_RASSERT, MS_OP_DELAY,MS_OP_SET, MS_OP_DBRA, MS_OP_BRSET, MS_OP_BRCLEAR, MS_OP_RET, MS_OP_C_CALL, MS_OP_PTR, MS_OP_ADELAY, MS_OP_BRSTAT, MS_OP_SUBRET, MS_OP_CALL, MS_OP_RASSERT_P, MS_OP_RFETCH_P, and MS_OP_TRIG.

Execution context

The execution context of microinstructions is:

• the program counter which points to the next microinstruction to execute either in the main microsequence or in a sub-call
• the current value of ptr which points to the next char to send/receive
• the current value of the internal branch register

This data is modified by some of the microinstructions but not all.

Detailed description

MS_OP_GET and MS_OP_PUT

These microinstructions are used to do either predefined standard IEEE1284-1994 transfers or programmed non-standard I/O.

MS_OP_RFETCH

Register FETCH is used to retrieve the current value of a parallel port register, apply a mask and save it in a buffer.
Parameters:

1. register
2. character mask
3. pointer to the buffer

Predefined macro: MS_RFETCH(reg,mask,ptr)

MS_OP_RSET

Register SET is used to assert/clear some bits of a particular parallel port register, two masks are applied.
Parameters:

1. register
2. mask of bits to assert
3. mask of bits to clear

Predefined macro: MS_RSET(reg,assert,clear)

MS_OP_RASSERT

Register ASSERT is used to assert all bits of a particular parallel port register.
Parameters:

1. register
2. byte to assert

Predefined macro: MS_RASSERT(reg,byte)

MS_OP_DELAY

Microsecond DELAY is used to delay the execution of the microsequence.
Parameter: delay in microseconds.
Predefined macro: MS_DELAY(delay)

MS_OP_SET

SET Internal Branch Register is used to set the value of the internal branch register.
Parameter: integer value
Predefined macro: MS_SET(accum)

MS_OP_DBRA

Do BRAnch is used to branch if internal branch register decremented by one result value is positive.
Parameter: integer offset in the current executed (sub)microsequence.
The offset is added to the index of the next microinstruction to execute.
Predefined macro: MS_DBRA(offset)

MS_OP_BRSET

BRanch On SET is used to branch if some of the status register bits of the parallel port are set.
Parameters:

1. bits of the status register
2. integer offset in the current executed (sub)microsequence.

The offset is added to the index of the next microinstruction to execute.
Predefined macro: MS_BRSET(mask,offset)

MS_OP_BRCLEAR

BRanch on CLEAR is used to branch if some of the status register bits of the parallel port are cleared.
Parameter:

1. bits of the status register
2. integer offset in the current executed (sub)microsequence.

The offset is added to the index of the next microinstruction to execute.
Predefined macro: MS_BRCLEAR(mask,offset)

MS_OP_RET

RETurn is used to return from a microsequence. This instruction is mandatory. This is the only way for the microsequencer to detect the end of the microsequence. The return code is returned in the integer pointed by the (int *) parameter of the ppb_MS_microseq().
Parameter: integer return code
Predefined macro: MS_RET(code)

MS_OP_C_CALL

C function CALL is used to call C functions from microsequence execution. This may be useful when a non-standard i/o is performed to retrieve a data character from the parallel port.
Parameters:

1. the C function to call
2. the parameter to pass to the function call

The C function shall be declared as a int(*)(void *p, char *ptr). The ptr parameter is the current position in the buffer currently scanned.
Predefined macro: MS_C_CALL(func,param)

MS_OP_PTR

Initialize Internal PTR is used to initialize the internal pointer to the currently scanned buffer. This pointer is passed to any C call (see above).
Parameter: pointer to the buffer that shall be accessed by xxx_P() microsequence calls. Note that this pointer is automatically incremented during xxx_P() calls.
Predefined macro: MS_PTR(ptr)

MS_OP_ADELAY

Asynchronous DELAY is used to make a tsleep() during microsequence execution. The tsleep is executed at PPBUSPRI level.
Parameter: delay in ms
Predefined macro: MS_ADELAY(delay)

MS_OP_BRSTAT

BRanch on STATe is used to branch on status register state condition.
Parameters:

1. mask of asserted bits. Bits that shall be asserted in the status register are set in the mask
2. mask of cleared bits. Bits that shall be cleared in the status register are set in the mask
3. integer offset in the current executed (sub)microsequence.

The offset is added to the index of the next microinstruction to execute.
Predefined macro: MS_BRSTAT(asserted_bits,clear_bits,offset)

MS_OP_SUBRET

Sub-microsequence RETurn is used to return from the sub-microsequence call. This action is mandatory before a RET call. Some microinstructions (PUT, GET) may not be callable within a sub-microsequence.
No parameter.
Predefined macro: MS_SUBRET()

MS_OP_CALL

Sub-microsequence CALL is used to call a sub-microsequence. A sub-microsequence is a microsequence with a SUBRET call.
Parameter: the sub-microsequence to execute
Predefined macro: MS_CALL(microseq)

MS_OP_RASSERT_P

Register ASSERT from internal PTR is used to assert a register with data currently pointed by the internal PTR pointer.
Parameters:

1. amount of data to write to the register
2. register

Predefined macro: MS_RASSERT_P(iter,reg)

MS_OP_RFETCH_P

Register FETCH to internal PTR is used to fetch data from a register. Data is stored in the buffer currently pointed by the internal PTR pointer.
Parameters:

1. amount of data to read from the register
2. register
3. mask applied to fetched data

Predefined macro: MS_RFETCH_P(iter,reg,mask)

MS_OP_TRIG

TRIG register is used to trigger the parallel port. This microinstruction is intended to provide a very efficient control of the parallel port. Triggering a register is writing data, wait a while, write data, wait a while... This allows the writing of magic sequences to the port.
Parameters:

1. amount of data to read from the register
2. register
3. size of the array
4. array of unsigned chars. Each couple of u_chars defines the data to write to the register and the delay in microseconds to wait. The delay is limited to 255 us to simplify and reduce the size of the array.

Predefined macro: MS_TRIG(reg,len,array)

MICROSEQUENCES

C structures

	union ppb_insarg {
		int i;
		char c;
		void *p;
		int (* f)(void *, char *);
	};
	struct ppb_microseq {
		int opcode; /* microins. opcode */
		union ppb_insarg arg[PPB_MS_MAXARGS]; /* arguments */
	};

Using microsequences

To instantiate a microsequence, just declare an array of ppb_microseq structures and initialize it as needed. You may either use predefined macros or code directly your microinstructions according to the ppb_microseq definition. For example,

	struct ppb_microseq select_microseq[] = {
		/* parameter list
		*/
		#define SELECT_TARGET MS_PARAM(0, 1, MS_TYP_INT)
		#define SELECT_INITIATOR MS_PARAM(3, 1, MS_TYP_INT)
		/* send the select command to the drive */
		MS_DASS(MS_UNKNOWN),
		MS_CASS(H_nAUTO | H_nSELIN | H_INIT | H_STROBE),
		MS_CASS( H_AUTO | H_nSELIN | H_INIT | H_STROBE),
		MS_DASS(MS_UNKNOWN),
		MS_CASS( H_AUTO | H_nSELIN | H_nINIT | H_STROBE),
		/* now, wait until the drive is ready */
		MS_SET(VP0_SELTMO),
		/* loop: */ MS_BRSET(H_ACK, 2 /* ready */),
		MS_DBRA(-2 /* loop */),
		/* error: */ MS_RET(1),
		/* ready: */ MS_RET(0)
	};

Here, some parameters are undefined and must be filled before executing the microsequence. In order to initialize each microsequence, one should use the ppb_MS_init_msq() function like this:

	ppb_MS_init_msq(select_microseq, 2,
		SELECT_TARGET, 1 << target,
		SELECT_INITIATOR, 1 << initiator);

and then execute the microsequence.

The microsequencer

The microsequencer is executed either at ppbus or adapter level (see ppbus(4) for info about ppbus system layers). Most of the microsequencer is executed at atppc level to avoid ppbus to adapter function call overhead. But some actions like deciding whereas the transfer is IEEE1284-1994 compliant are executed at ppbus layer.

BUGS

• Only one level of submicrosequences is allowed.
• When triggering the port, maximum delay allowed is 255 us.

SEE ALSO

ppbus(4), atppc(4), vpo(4)

HISTORY

The microseq manual page first appeared in FreeBSD 3.0.

AUTHORS

This manual page is based on the FreeBSD microseq(9) manual page and was update for NetBSD's port by by Gary Thorpe.

December 29, 2003