View 1991288_964036.PDF datasheet online --- IC-ON-LINE

Datasheet File OCR Text:

TUPP+622 (PM5363) Driver Manual
PM5363
TUPP+622
SONET/SDH TRIBUTARY UNIT PAYLOAD PROCESSOR
DRIVER MANUAL
DOCUMENT ISSUE 2 ISSUED: FEBRUARY, 2001
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
TUPP+622 (PM5363) Driver Manual
ABOUT THIS MANUAL AND TUPP+622
This manual describes the TUPP+622 device driver. It describes the driver's functions, data structures, and architecture. This manual focuses on the driver's interfaces to your application, Real-Time Operating System, and the devices. It also describes in general terms how to modify and port the driver to your software and hardware platform.
Audience
This manual was written for people who need to: * * * Evaluate and test the TUPP+622 devices Modify and add to the TUPP+622 driver's functions Port the TUPP+622 driver to a particular platform.
References
For more information about the TUPP+622 driver, see the driver's release notes. For more information about the TUPP+622 device, see the documents listed in Table 1 and any related errata documents. Table 1: Related Documents Document Name TUPP+622 Telecom Standard Product Data Sheet SONET/SDH Tributary Unit Payload Processor / Monitor for 622 Mbit/s Interfaces (TUPP+622) Short Form Data Sheet Document Number PMC-1981421 PMC-1981272
Note: Ensure that you use the document that PMC-Sierra issued for your version of the device and driver.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
2
TUPP+622 (PM5363) Driver Manual
Revision History
Issue No. Issue 1 Issue 2 Issue Date January 2000 February 2001 Details of Change Document created 1) Modified the alarm, status and statistics architecture (structures and APIs): a) removed MSB and DSB structures as well as tuppClearStats() API since statistics are no longer accumulated inside the driver. b) Added sTUP_STATUS_XX and sTUP_CNT_XX structures to add granularity. c) replaced tuppGetStats() API with tuppGetCnt() and tuppGetStatus() APIs. 2) Fixed various typos and formatting issues."
Legal Issues
None of the information contained in this document constitutes an express or implied warranty by PMC-Sierra, Inc. as to the sufficiency, fitness or suitability for a particular purpose of any such information or the fitness, or suitability for a particular purpose, merchantability, performance, compatibility with other parts or systems, of any of the products of PMC-Sierra, Inc., or any portion thereof, referred to in this document. PMC-Sierra, Inc. expressly disclaims all representations and warranties of any kind regarding the contents or use of the information, including, but not limited to, express and implied warranties of accuracy, completeness, merchantability, fitness for a particular use, or non-infringement. In no event will PMC-Sierra, Inc. be liable for any direct, indirect, special, incidental or consequential damages, including, but not limited to, lost profits, lost business or lost data resulting from any use of or reliance upon the information, whether or not PMC-Sierra, Inc. has been advised of the possibility of such damage. The information is proprietary and confidential to PMC-Sierra, Inc., and for its customers' internal use. In any event, no part of this document may be reproduced in any form without the express written consent of PMC-Sierra, Inc. (c) 2001 PMC-Sierra, Inc. PMC-1991288 (R2), ref PMC-990877 (R2)
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
3
TUPP+622 (PM5363) Driver Manual
Contacting PMC-Sierra
PMC-Sierra, Inc. 105-8555 Baxter Place Burnaby, BC Canada V5A 4V7 Tel: (604) 415-6000 Fax: (604) 415-6200 Document Information: document@pmc-sierra.com Corporate Information: info@pmc-sierra.com Technical Support: apps@pmc-sierra.com Web Site: http://www.pmc-sierra.com
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
4
TUPP+622 (PM5363) Driver Manual
TABLE OF CONTENTS
About this Manual and TUPP+622 ......................................................................................2 Audience.................................................................................................................2 References .............................................................................................................2 Revision History......................................................................................................3 Legal Issues ...........................................................................................................3 Contacting PMC-Sierra...........................................................................................4 Table of Contents.................................................................................................................5 List of Figures ....................................................................................................................10 List of Tables...................................................................................................................... 11 1 2 3 3.1 Driver Porting Quick Start ..........................................................................................12 Driver Functions and Features ..................................................................................13 Software Architecture.................................................................................................15 Driver External Interfaces .......................................................................................15 Application Programming Interface ......................................................................15 Real-Time OS Interface........................................................................................16 Driver Hardware Interface ....................................................................................16 Main Components ...................................................................................................16 Alarms, Status and Statistics ................................................................................17 Input / Output (IO).................................................................................................17 Tributary Payload Processor (VTPP) ...................................................................18 Tributary Path Overhead Processor (RTOP)........................................................18 Tributary Trace Buffer (RTTB) ..............................................................................18 Module Data Block (MDB) ....................................................................................18 Device Data Blocks (DDB) ...................................................................................18 Interrupt-Service Routine .....................................................................................18 Deferred-Processing Routine ...............................................................................19 Software States .......................................................................................................19 Module States.......................................................................................................20 Device States........................................................................................................21 Processing Flows ....................................................................................................22 Module Management............................................................................................22 Device Management ............................................................................................23 Interrupt Servicing ...................................................................................................24 Calling tuppISR.....................................................................................................24 Calling tuppDPR ...................................................................................................25 Calling tuppPoll.....................................................................................................26
3.2
3.3
3.4
3.5
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
5
TUPP+622 (PM5363) Driver Manual
4 4.1 4.2
Data Structures ..........................................................................................................27 Constants ................................................................................................................28 Structures Passed by the Application......................................................................28 Module Initialization Vector: MIV ..........................................................................28 Device Initialization Vector: DIV ...........................................................................29 Initialization Profile: INIT_PROF...........................................................................30 ISR Enable/Disable Mask.....................................................................................33 Device and Alarm Status ......................................................................................34 Statistic Counters: CNT ........................................................................................36 Statistic Counter Configuration: CFG_CNT..........................................................37 Structures in Allocated Memory ..............................................................................37 Module Data Block ...............................................................................................37 Device Data Block ................................................................................................38 Structures Passed Through RTOS Buffers .............................................................40 Interrupt-Service Vector: ISV................................................................................40 Deferred-Processing Vector: DPV........................................................................40 Global Variable........................................................................................................41 Application Programming Interface ...........................................................................42 Module Initialization.................................................................................................42 Opening the Driver Module: tuppModuleOpen.....................................................42 Closing the Driver Module: tuppModuleClose......................................................42 Module Activation ....................................................................................................43 Starting the Driver Module: tuppModuleStart .......................................................43 Stopping the Driver Module: tuppModuleStop......................................................43 Initialization Profile Management ............................................................................44 Creating an Initialization Profile: tuppAddInitProfile .............................................44 Retrieving an Initialization Profile: tuppGetInitProfile ...........................................44 Deleting an Initialization Profile: tuppDeleteInitProfile..........................................45 Device Addition and Deletion ..................................................................................45 Adding a Device: tuppAdd....................................................................................45 Deleting a Device: tuppDelete..............................................................................46 Device Initialization .................................................................................................46 Initializing a Device: tuppInit.................................................................................46 Updating the Configuration of a Device: tuppUpdate...........................................47 Resetting a Device: tuppReset.............................................................................47 Device Activation and De-Activation .......................................................................48 Activating a Device: tuppActivate .........................................................................48 DeActivating a Device: tuppDeActivate................................................................48 Device Reading and Writing ...................................................................................49 Reading from a Device Register: tuppRead.........................................................49
4.3
4.4
4.5 5 5.1
5.2
5.3
5.4
5.5
5.6
5.7
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
6
TUPP+622 (PM5363) Driver Manual
Writing to a Device: tuppWrite ..............................................................................49 Reading a Block of Registers: tuppReadBlock ....................................................50 Writing a Block of Registers: tuppWriteBlock .......................................................50 5.8 Input/Output ............................................................................................................51 Configuring Auto-Responses: tuppAutoResponse...............................................51 Tributary Payload Processor...................................................................................52 Configuring Position of the J1 Byte: tuppVTPPConfigJ1 .....................................52 Inserting all 0s in H4: tuppVTPPSquelchH4.........................................................52 Forcing Path AIS: tuppVTPPForcePAIS...............................................................53 Forcing Path IDLE: tuppVTPPForceIDLE ............................................................53 Forcing Loss of Pointer: tuppVTPPDiagLOP .......................................................54
5.9
5.10 Tributary Path Overhead Processors......................................................................54 Forcing PDIV Output High: tuppRTOPForcePDIVHigh........................................54 Getting/Setting Path Signal Label: tuppRTOPPathSigLabel................................55 Configuring Tributary AIS Auto-Responses: tuppAutoResponseTribAIS .............56 Configuring In-Band Error Reporting: tuppAutoResponseTribIBER ....................56 5.11 Tributary Trace Buffer..............................................................................................57 Getting/Setting Tributary Trace Messages: tuppTributaryTraceMsg ....................57
5.12 Interrupt Service Functions .....................................................................................58 Getting the Interrupt Mask: tuppGetMask ............................................................58 Setting the Interrupt Mask: tuppSetMask .............................................................58 Clearing the Interrupt Mask: tuppClearMask........................................................58 Polling Interrupt Status Registers: tuppPoll..........................................................59 Interrupt-Service Routine: tuppISR ......................................................................59 Deferred-Processing Routine: tuppDPR ..............................................................60 5.13 Alarm, Status and Statistics Functions....................................................................60 Configuring Statistical Counts: tuppCfgStats........................................................60 Getting the Current Status: tuppGetStatus ...........................................................61 Reading the Device Counters: tuppGetCnt..........................................................61 5.14 Device Diagnostics..................................................................................................62 Verifying Register Access: tuppTestReg ..............................................................62 5.15 Callback Functions..................................................................................................62 IO Section Callbacks: cbackTuppIO.....................................................................63 VTPP Section Callbacks: cbackTuppVTPP .........................................................63 RTOP Section Callbacks: cbackTuppRTOP ........................................................64 RTTB Section Callbacks: cbackTuppRTTB .........................................................64 6 6.1 Hardware Interface ....................................................................................................65 Device I/O ...............................................................................................................65 Reading Registers: sysTuppRead........................................................................65 Writing Values: sysTuppWrite...............................................................................65 Interrupt Servicing ...................................................................................................66 Installing the ISR Handler: sysTuppISRHandlerInstall .........................................66
6.2
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
7
TUPP+622 (PM5363) Driver Manual
ISR Handler: sysTuppISRHandler........................................................................66 Removing Handlers: sysTuppISRHandlerRemove ..............................................67 DPR Task: sysTuppDPRTask ...............................................................................67 7 7.1 RTOS Interface..........................................................................................................68 Memory Allocation / De-Allocation ..........................................................................68 Allocating Memory: sysTuppMemAlloc ................................................................68 Freeing Memory: sysTuppMemFree ....................................................................68 Buffer Management.................................................................................................69 Starting Buffer Management: sysTuppBufferStart ................................................69 Getting DPV Buffers: sysTuppDPVBufferGet.......................................................69 Getting ISV Buffers: sysTuppISVBufferGet ..........................................................70 Returning DPV Buffers: sysTuppDPVBufferRtn...................................................70 Returning ISV Buffers: sysTuppISVBufferRtn ......................................................70 Stopping Buffer Management: sysTuppBufferStop ..............................................71 Preemption..............................................................................................................71 Disabling Preemption: sysTuppPreemptDisable ..................................................71 Re-Enabling Preemption: sysTuppPreemptEnable..............................................72 Timers 72 Suspending a Task Execution: sysTuppTimerSleep ............................................72 Porting Drivers ...........................................................................................................73 Driver Source Files..................................................................................................73 Driver Porting Procedures.......................................................................................74 Step 1: Porting the RTOS interface ......................................................................75 Step 2: Porting the Hardware Interface ................................................................76 Step 3: Porting the Application-Specific Elements................................................77 Step 4: Building the Driver....................................................................................77
7.2
7.3
7.4
8 8.1 8.2
Appendix A: Driver Return Codes .....................................................................................79 Appendix B: Coding Conventions......................................................................................80 Variable Type Definitions ......................................................................................80 Naming Conventions ............................................................................................80 Macros..................................................................................................................81 Constants..............................................................................................................81 Structures .............................................................................................................82 Functions ..............................................................................................................82 Variables ...............................................................................................................82 File Organization ..................................................................................................83 API Files ...............................................................................................................83 Hardware Dependent Files...................................................................................84 RTOS Dependent Files ........................................................................................84 Other Driver Files .................................................................................................84 Acronyms...........................................................................................................................85
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
8
TUPP+622 (PM5363) Driver Manual
List of Terms ......................................................................................................................86 Index ..................................................................................................................................87
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
9
TUPP+622 (PM5363) Driver Manual
LIST OF FIGURES
Figure 1: Driver Interfaces .................................................................................................15 Figure 2: Driver Architecture .............................................................................................17 Figure 3: Driver Software States .......................................................................................20 Figure 4: Module Management Flow Diagram ..................................................................22 Figure 5: Device Management Flow Diagram ...................................................................23 Figure 6: Interrupt Service Model ......................................................................................24 Figure 7: Polling Service Model.........................................................................................26 Figure 8: Simplified SDH/Sonet Multiplexing Structures ...................................................27
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
10
TUPP+622 (PM5363) Driver Manual
LIST OF TABLES
Table 1: Driver Functions and Features ............................................................................13 Table 2: Module Initialization Vector: sTUP_MIV..............................................................28 Table 3: Device Initialization Vector: sTUP_DIV ...............................................................29 Table 4: Initialization Profile: sTUP_INIT_PROF ..............................................................30 Table 5: Initialization Data: sTUP_INIT_DATA_NORM ....................................................30 Table 6: Initialization Data: sTUP_INIT_DATA_COMP.....................................................31 Table 7: Initialization Data: sTUP_INIT_DATA_FRM........................................................32 Table 8: ISR Mask: sTUP_MASK......................................................................................33 Table 9: Alarm Status (sTUP_STATUS) ...........................................................................34 Table 10: Input/Output Status (sTUP_STATUS_IO).........................................................34 Table 11: VTPP Status (sTUP_STATUS_VTPP)..............................................................35 Table 12: RTOP Status (sTUP_STATUS_RTOP) ............................................................35 Table 13: RTTB Status (sTUP_STATUS_RTTB)..............................................................36 Table 14: Statistic Counters (sTUP_STAT_CNT) .............................................................36 Table 15: Counters Config (sTUP_CFG_CNT).................................................................37 Table 16: Module Data Block: sTUP_MDB .......................................................................38 Table 17: Device Data Block: sTUP_DDB ........................................................................38 Table 18: Interrupt-Service Vector: sTUP_ISV .................................................................40 Table 19: Deferred-Processing Vector: sTUP_DPV .........................................................41 Table 20: Return Codes ....................................................................................................79 Table 21: Variable Type Definitions ..................................................................................80 Table 22: Naming Conventions .........................................................................................80 Table 23: File Naming Conventions ..................................................................................83
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
11
Tupp+622 (PM5363) Driver Manual Driver Porting Quick Start
1
DRIVER PORTING QUICK START
This section summarizes how to port the TUPP+622 device driver to your hardware and operating system (OS) platform. For more information about porting the TUPP+622 driver, see Section 8 (page 73). Since each platform and application is unique, this manual can only offer guidelines for porting the TUPP+622 driver. The code for the TUPP+622 driver is organized into C source files. You may need to modify the code or develop additional code. The code is in the form of constants, macros, and functions. For ease of porting, the code is grouped into source files (src) and includes files (inc). The source files contain the functions and the include files contain the constants and macros. To port the TUPP+622 driver to your platform: 1. Port the driver's OS extensions (page 75): Data types OS-specific services Utilities and interrupt services that use OS-specific services
2. Port the driver to your hardware interface (page 76): Port low-level device read-and-write macros. Define hardware system-configuration constants.
3. Port the driver's application-specific elements (page 77): Define the task-related constants. Code the callback functions.
4. Build the driver (page 77).
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
12
Tupp+622 (PM5363) Driver Manual Driver Functions and Features
2
DRIVER FUNCTIONS AND FEATURES
This section describes the main functions and features supported by the TUPP+622 driver. Table 1: Driver Functions and Features Function Open / Close Driver Module (page 42) Description Opening the driver module allocates all the memory needed by the driver and initializes all module level data structures. Closing the driver module shuts down the driver module gracefully after deleting all devices that are currently registered with the driver, and releases all the memory allocated by the driver. Starting the driver module involves allocating all RTOS resources needed by the driver such as timers and semaphores (except for memory, which is allocated during the Open call). Stopping the driver module involves de-allocating all RTOS resources allocated by the driver without changing the amount of memory allocated to it. Add / Delete Device (page 45) Deleting a device involves shutting down the device and clearing the memory used for storing context information about this device. Device Initialization (page 46) Activate / DeActivate Device (page 48) On the contrary, de-activating a device removes it from its operating state, disables interrupts and other global registers. Read / Write Device Registers (page 49) These functions provide a `raw' interface to the device. Device registers that are both directly and indirectly accessible are available for both inspection and modification via these functions. If applicable, block reads and writes are also available. Activating a device puts it into its normal mode of operation by enabling interrupts and other global registers. A successful device activation also enables other API invocations. The initialization function resets then initializes the device and any associated context information about it. The driver uses this context information to control and monitor the TUPP+622 device. Adding a device involves verifying that the device exists, associating a device Handle to the device, and storing context information about it. The driver uses this context information to control and monitor the device.
Start / Stop Driver Module (page 43)
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
13
Tupp+622 (PM5363) Driver Manual Driver Functions and Features
Function
Description
Interrupt Servicing Interrupt Servicing is an optional feature. The user can disable device / Polling interrupts and instead poll the device periodically to monitor status and check for alarm/error conditions. (page 58) Both polling and interrupt driven approaches detect a change in device status and report the status to a Deferred-Processing Routine (DPR). The DPR then invokes application callback functions based on the status information retrieved. This allows the driver to report significant events that occur within the device to the application. Statistics Collection (page 60) Functions are provided to retrieve a snapshot of the various counts that are accumulated by the TUPP+622 device. Routines should be invoked often enough to avoid letting the counters to rollover.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
14
Tupp+622 (PM5363) Driver Manual Software Architecture
3
SOFTWARE ARCHITECTURE
This section describes the software architecture of the TUPP+622 device driver. This includes a discussion of the driver's external interfaces and its main components.
3.1
Driver External Interfaces
Figure 1 illustrates the external interfaces defined for the TUPP+622 device driver. Figure 1: Driver Interfaces
Application
Function Calls
Application Callbacks
Service Callbacks
TUPP+622 Device Driver
RTOS
Service Calls
Hardware Interrupts
Register Accesses
TUPP+622 Devices
Application Programming Interface
The driver's API is a collection of high level functions that can be called by application programmers to configure, control, and monitor the TUPP+622 device, such as: * * Initializing the device Validating device configuration
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
15
Tupp+622 (PM5363) Driver Manual Software Architecture
* *
Retrieving device status and statistics information. Diagnosing the device
The driver API functions use the driver library functions as building blocks to provide this system level functionality to the application programmer (see below). The driver API also consists of callback functions that notify the application of significant events that take place within the device and driver, including alarms reporting.
Real-Time OS Interface
The driver's RTOS interface module provides functions that let the driver use RTOS services. The TUPP+622 driver requires the memory, interrupt, and preemption services from the RTOS. The RTOS interface functions perform the following tasks for the TUPP+622 device and driver: * * * Allocate and deallocate memory Manage buffers for the ISR and DPR Disable and enable preemption
The RTOS interface also includes service callbacks. These are functions installed by the driver using RTOS service calls, such as installing the ISR handler and the DPR task. These service callbacks are invoked when an interrupt occurs or the DPR is scheduled. Note: You must modify RTOS interface code to suit your RTOS.
Driver Hardware Interface
The TUPP+622 hardware interface provides functions that read from and write to device-registers. The hardware interface also provides a template for an ISR that the driver calls when the device raises a hardware interrupt. You must modify this function based on the interrupt configuration of your system.
3.2
Main Components
Figure 2 illustrates the top level architectural components of the TUPP+622 device driver. This applies in polled and interrupt driven operation. In polled operation the ISR is called periodically. In interrupt operation the interrupt directly triggers the ISR. The driver includes the following main components: * * * * Module and Device(s) Data-Blocks Interrupt-Processing Routine Deferred-Processing Routine Alarm, Status and Statistics
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
16
Tupp+622 (PM5363) Driver Manual Software Architecture
* * * *
Input/Output Tributary Payload Processor (VTPP) Tributary Path Overhead Processor (RTOP) Tributary Trace Buffer (RTTB)
Figure 2: Driver Architecture
Application Function Calls Application Callbacks Driver API Service Callbacks RTOS Interface Service Calls RTOS
Deferred Processing Routine
Alarm, Status & Statistics
Input/Output (IO)
Interrupt Context
Module Data Block Device Data Blocks
Tributary Payload Processor (VTPP) Tributary Path Overhead Processor (RTOP) Tributary Trace Buffer (RTTB)
Interrupt Service Routine
.......
Hardware Interface Hardware Interrupts TUPP+622 Devices Register Accesses
Alarms, Status and Statistics
Alarm, Status and Statistics is responsible for monitoring alarms, tracking devices status information and reading the statistical counts for each device registered with (added to) the driver.
Input / Output (IO)
The Input / Output is responsible for configuring the input de-multiplexer and output multiplexer. Functions are provided for monitoring the major TUPP+622 inputs.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
17
Tupp+622 (PM5363) Driver Manual Software Architecture
Tributary Payload Processor (VTPP)
The Tributary Payload Processor (VTPP) detects and reports the path overhead errors. Functions are provided for configuring the J1 position. For diagnostics purposes at the tributary level, functions are also provided to force insertion of path AIS, path Idle, as well as inversion of the NDF field in the outgoing payload.
Tributary Path Overhead Processor (RTOP)
The Tributary Path Overhead Processor (RTOP) detects and report REI, RDI and RFI. Functions are provided to monitor the tributary performance by giving access to the REI and BIP-2 error counts. A function is also provided to give an easy read/write access to the Path Signal Label for each tributary.
Tributary Trace Buffer (RTTB)
Functions are provided to read and write the expected and captured tributary path trace message (J2).
Module Data Block (MDB)
The Module Data Block (MDB) is the top-layer data structure, created by the TUPP+622 device driver to keep track of its initialization and operating parameters, modes and dynamic data. The MDB is allocated via an RTOS call, when the driver module is opened and contains all the device structures
Device Data Blocks (DDB)
The Device Data Blocks (DDB) are contained in the MDB and they are allocated when the module is opened. They are initialized by the TUPP+622 device driver for each device that is registered, to keep track of that device's initialization and operating parameters, modes and dynamic data. There is a limit on the number of devices that can be registered with the driver module. This number is set when the driver module is opened.
Interrupt-Service Routine
The TUPP+622 driver provides an ISR called tuppISR that checks if there is any valid interrupt conditions present for the device. This function can be used by a system-specific interrupt-handler function to service interrupts raised by the device. The low-level interrupt-handler function that traps the hardware interrupt and calls tuppISR is system and RTOS dependent. Therefore, it is outside the scope of the driver. Example implementations of an interrupt handler and functions that install and remove it are provided as a reference on page 66. You can customize these example implementations to suit your specific needs.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
18
Tupp+622 (PM5363) Driver Manual Software Architecture
Deferred-Processing Routine
The DPR provided by the TUPP+622 driver (tuppDPR) clears and processes interrupt conditions for the device. Typically, a system specific function, which runs as a separate task within the RTOS, executes the DPR. See page 24 for a detailed explanation of the DPR and interrupt-servicing model.
3.3
Software States
Figure 3 shows the software state diagrams for the TUPP+622 module and device(s) as maintained by the driver. State transitions occur on the successful execution of the corresponding transition functions shown. State information helps maintain the integrity of the driver's DDB by controlling the set of device operations allowed in each state.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
19
Tupp+622 (PM5363) Driver Manual Software Architecture
Figure 3: Driver Software States
tuppModuleOpen Idle tuppModuleClose Start
tuppModuleStop
tuppModuleStart
tuppModuleClose
Ready
MODULE STATES
Start
tuppAdd
tuppDelete
Present tuppReset tuppInit tuppActivate Inactive tuppDeActivate PER-DEVICE STATES Active tuppReset
Module States
The following is a description of the TUPP+622 module states. See sections 5.1 and 5.2 for a detailed description of the API functions that are used to change the module state. Start The driver module has not been initialized. In this state the driver does not hold any RTOS resources (memory, timers, etc); has no running tasks, and performs no actions.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
20
Tupp+622 (PM5363) Driver Manual Software Architecture
Idle The driver module has been initialized successfully. The Module Initialization Vector (MIV) has been validated, the Module Data Block (MDB) has been allocated and loaded with current data, the per-device data structures have been allocated, and the RTOS has responded without error to all the requests sent to it by the driver. Ready This is the normal operating state for the driver module. This means that all RTOS resources have been allocated and the driver is ready for devices to be added. The driver module remains in this state while devices are in operation.
Device States
The following is a description of the TUPP+622 per-device states. The state mentioned here is the software state as maintained by the driver, and not as maintained inside the device itself. See sections 5.4, 5.5 and 5.6 for a detailed description of the API functions that are used to change the per-device state. Start The device has not been initialized. In this state the device is unknown by the driver and performs no actions. There is a separate flow for each device that can be added, and they all start here. Present The device has been successfully added. A Device Data Block (DDB) has been associated to the device and updated with the user context, and a device handle has been given to the user. In this state, the device performs no actions. Inactive In this state the device is configured but all data functions are de-activated including interrupts and alarms, status and statistics functions. Active This is the normal operating state for the device. In this state, interrupt servicing or polling is enabled.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
21
Tupp+622 (PM5363) Driver Manual Software Architecture
3.4
Processing Flows
This section describes the main processing flows of the TUPP+622 driver modules. The flow diagrams presented here illustrate the sequence of operations that take place for different driver functions. The diagrams also serve as a guide to the application programmer by illustrating the sequence in which the application must invoke the driver API.
Module Management
The following diagram illustrates the typical function call sequences that occur when initializing or shutting down the TUPP+622 driver module. Figure 4: Module Management Flow Diagram
START Performs module level initialization of the driver. Validates the Module Initialization Vector (MIV). Allocates memory for the MDB and all its components (i.e. all the memory needed by the driver) and then initializes the contents of the MDB with the validated MIV. Performs module level startup of the driver. This involves allocating RTOS resources such as semaphores and timers and installing the ISR handler and DPR task. Register an initialization profile. This allows the user to store pre-defined parameter vectors that are validated ahead of time. When the deviceinitialization function is invoked only a profile number need to be passed. This method simplifies and expedites the above operations. Perform all device level functions here (add, init, activate, de-activate, reset, delete,...) tuppDeleteInitProfile De-register an initialization profile previously registered with the driver.
tuppModuleOpen
tuppModuleStart
tuppAddInitProfile
tuppModuleStop
Performs Module level shutdown of the driver. This involves deleting all devices currently installed and de-allocating all timers and semaphores as well as removing the ISR handler and DPR task.
tuppModuleClose
Performs module level shutdown of the driver. De-allocates all the driver's memory.
END
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
22
Tupp+622 (PM5363) Driver Manual Software Architecture
Device Management
The following diagram shows the functions and process that the driver uses to add, initialize, reinitialize, and delete the TUPP+622 device. Figure 5: Device Management Flow Diagram
START
tuppAdd
Detects the new device in hardware, assigns a DDB to the new device and stores the user's context for the device. Returns a device handle to the user. Applies a reset to the device and initializes the device registers and associated RAMs based on the DIV passed by the user. The user may only pass a profile number, which corresponds to a previously saved & validated set of configurations (by using tuppAddInitProfile).
tuppInit
tuppActivate
Prepares the device for normal operation by enabling interrupts and other global enables. ISR routines are installed when the module is started using sysTuppISRHandlerInstall. The device is now operational and all other API can be invoked.
tuppReset
In order to re-initialize the device, reset the device using tuppReset and go through the initialization sequence again.
tuppDeActivate
De-activates the device and removes it from normal operation. This involves disabling the device interrupts. ISR routines for this device are removed using sysTuppISRHandlerRemove when the module is closed.
tuppReset
Applies a software reset to the device to put it in its default startup state.
tuppDelete
Removes the device from the list of devices being controlled by the TUPP+622 driver. This function de-allocates the device context information for the device being deleted.
END
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
23
Tupp+622 (PM5363) Driver Manual Software Architecture
3.5
Interrupt Servicing
The TUPP+622 driver services device interrupts using an Interrupt-Service Routine (ISR) that traps interrupts and a Deferred-Processing Routine (DPR) that actually processes the interrupt conditions and clears them. This lets the ISR execute quickly and exit. Most of the time-consuming processing of the interrupt conditions is deferred to the DPR by queuing the necessary interrupt-context information to the DPR task. The DPR function runs in the context of a separate task within the RTOS. Note: Since the DPR task processes potentially serious interrupt conditions, you should set the DPR task's priority higher than the application task interacting with the TUPP+622 driver. The driver provides the system-independent functions, tuppISR and tuppDPR. You must fill in the corresponding system-specific functions, sysTuppISRHandler and sysTuppDPRTask. The system-specific functions isolate the system-specific communication mechanism (between the ISR and DPR) from the system-independent functions, tuppISR and tuppDPR. Figure 6 illustrates the interrupt service model used in the TUPP+622 driver design. Figure 6: Interrupt Service Model
Interrupt Context Information
sysTuppISRHandler tuppISR
sysTuppDPRTask tuppDPR
Indication Callbacks Application
Note: Instead of using an interrupt service model, you can use a polling service model in the TUPP+622 driver to process the device's event-indication registers (see page 26).
Calling tuppISR
An interrupt handler function, which is system dependent, must call tuppISR. But first, the low-level interrupt-handler function must trap the device interrupts. You must implement this function to fit your own system. As a reference, an example implementation of the interrupt handler (sysTuppISRHandler) appears on page 66. You can customize this example implementation to suit your needs. The interrupt handler that you implement (sysTuppISRHandler) is installed in the interrupt vector table of the system processor. It is called when one or more TUPP+622 devices interrupt the processor. The interrupt handler then calls tuppISR for each device in the active state that has interrupt processing enabled.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
24
Tupp+622 (PM5363) Driver Manual Software Architecture
The tuppISR function reads from the master interrupt-status registers and the miscellaneous interrupt-status registers of the TUPP+622. If at least one valid interrupt condition is found then tuppISR fills an Interrupt-Service Vector (ISV) with this status information as well as the current device Handle. The tuppISR function also clears and disables all the device's interrupts detected. The sysTuppISRHandler function is then responsible to send this ISV buffer to the DPR task. Note: Normally you should save the status information for deferred interrupt processing by implementing a message queue.
Calling tuppDPR
The sysTuppDPRTask function is a system specific function that runs as a separate task within the RTOS. You should set the DPR task's priority higher than the application task(s) interacting with the TUPP+622 driver. In the message-queue implementation model, this task has an associated message queue. The task waits for messages from the ISR on this message queue. When a message arrives, sysTuppDPRTask calls the DPR (tuppDPR) with the received ISV. Then tuppDPR processes the status information and takes appropriate action based on the specific interrupt condition detected. The nature of this processing can differ from system to system. Therefore, tuppDPR calls different indication callbacks for different interrupt conditions. Typically, you should implement these callback functions as simple message posting functions that post messages to an application task. However, you can implement the indication callback to perform processing within the DPR task context and return without sending any messages. In this case, ensure that the indication function does not call any API functions that change the driver's state, such as tuppDelete. Also, ensure that the indication function is non-blocking because the DPR task executes while TUPP+622 interrupts are disabled. You can customize these callbacks to suit your system. See page 62 for example implementations of the callback functions. Note: Since the tuppISR and tuppDPR routines themselves do not specify a communication mechanism, you have full flexibility in choosing a communication mechanism between the two. A convenient way to implement this communication mechanism is to use a message queue, which is a service that most RTOS' provide. You must implement the two system specific functions, sysTuppISRHandler and sysTuppDPRTask. When the driver calls sysTuppISRHandlerInstall, the application installs sysTuppISRHandler in the interrupt vector table of the processor. The sysTuppDPRTask function is spawned as a task by the application. The sysTuppISRHandlerInstall function also creates the communication channel between sysTuppISRHandler and sysTuppDPRTask. This communication channel is most commonly a message queue associated with the sysTuppDPRTask. Similarly, during removal of interrupts, the driver removes sysTuppISRHandler from the microprocessor's interrupt vector table and deletes the task associated with sysTuppDPRTask. As a reference, this manual provides example implementations of the interrupt installation and removal functions on page 66. You can customize these prototypes to suit your specific needs.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
25
Tupp+622 (PM5363) Driver Manual Software Architecture
Calling tuppPoll
Instead of using an interrupt service model, you can use a polling service model in the TUPP+622 driver to process the device's event-indication registers. Figure 7 illustrates the polling service model used in the TUPP+622 driver design. Figure 7: Polling Service Model
Interrupt Context Information tuppDPR
tuppPoll tuppISR
Indication Callbacks Application
In polling mode, the application is responsible for calling tuppPoll often enough to service any pending error or alarm conditions. When tuppPoll is called, the tuppISR function is called internally. The tuppISR function reads from the master interrupt-status registers and the miscellaneous interrupt-status registers of the TUPP+622. If at least one valid interrupt condition is found then tuppISR fills an Interrupt-Service Vector (ISV) with this status information as well as the current device Handle. The tuppISR function also clears and disables all the device's interrupts detected. In polling mode, this ISV buffer is passed to the DPR task by calling tuppDPR internally.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
26
Tupp+622 (PM5363) Driver Manual Data Structures
4
DATA STRUCTURES
The TUPP+622 driver allows the User to configure the behavior of each tributary. The same structures are used independently of the mapping currently in use. Figure 8: Simplified SDH/Sonet Multiplexing Structures
STM-4
x4
STM-1
x1
AU-4 x3 AU-3 x7 TUG-2 TUG-3 x1 TU-3
x3
x1
TU-2/VT6
x2 VT-3 x3 TU-12/VT2
myField[stm1 index][au3 index][tug2 index][tu index]
x4
TU-11/VT1.5
Whenever a field within a structure refers to a specific TU, this field is declared as an array of [4][3][7][4], so that you can retrieve the value of this field by providing the STM1 #, AU3 #, TUG2 #, and TU # respectively in the indexes. If the mapping is not all TU11s, there will be some unused fields inside the structure. For example, if the mapping is all TU12s, there are only 3 TU12 per TUG2, so that all the [x][x][x][4] elements are unused and therefore invalid. If the mapping is all TU3s, a specific TU3 is defined by its STM1 #, TU3 # and therefore only the [x][x][1][1] are valid inside our structures, and all the remaining elements are unused. Note that the driver also uses substructures inside the high-level structures so that when a field is for a specific TU, the actual [4][3][7][4] array is often separated into arrays of [4] substructures that contain fields that are arrays of [3][7][4].
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
27
Tupp+622 (PM5363) Driver Manual Data Structures
4.1
Constants
The following Constants are used throughout the driver code: * error codes used throughout the driver code, returned by the API functions and used in the global error number field of the MDB and DDB. For more information on possible driver return codes, see Appendix A (page 79).
TUP_MAX_DEVS defines the maximum number of devices that can be supported by this
*
driver. This constant must not be changed without a thorough analysis of the consequences to the driver code. * *
TUP_MOD_START, TUP_MOD_IDLE, TUP_MOD_READY are the three possible module states
(stored in stateModule).
TUP_START, TUP_PRESENT, TUP_ACTIVE, TUP_INACTIVE are the four possible device
states (stored in stateDevice).
4.2
Structures Passed by the Application
These structures are defined for use by the application and are passed as argument to functions within the driver. These structures are the Module Initialization Vector (MIV), the Device Initialization Vector (DIV) and the ISR mask.
Module Initialization Vector: MIV
Passed via the tuppModuleOpen call, this structure contains all the information needed by the driver to initialize and connect to the RTOS. *
maxDevs is used to inform the driver how many devices will be operating concurrently
during this session. The number is used to calculate the amount of memory that will be allocated to the driver. The maximum value that can be passed is TUP_MAX_DEVS. Table 2: Module Initialization Vector: sTUP_MIV Field Name
pmdb maxDevs
Field Type
sTUP_MDB * UINT2
Field Description (pointer to) MDB Maximum number of devices supported during this session Maximum number of initialization profiles
maxInitProfs
UINT2
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
28
Tupp+622 (PM5363) Driver Manual Data Structures
Device Initialization Vector: DIV
Passed via the tuppInit call, this structure contains all the information needed by the driver to initialize a TUPP+622 device. This structure is also passed via the tuppAddInitProfile call when used as an initialization profile. * *
valid indicates that this initialization profile has been properly initialized and may be used
by the user. This field should be ignored when the DIV is passed directly.
pollISR is a flag that indicates the type of interrupt servicing the driver is to use. The
choices are `polling' (TUP_POLL_MODE), and `interrupt driven' (TUP_ISR_MODE). When configured in polling the Interrupt capability of the device is NOT used, and the user is responsible for calling tuppPoll periodically. The actual processing of the event information is the same for both modes. *
cbackIO, cbackVTPP, cbackRTOP and cbackRTTB are used to pass the address of
application functions that will be used by the DPR to inform the application code of pending events. If these fields are set as NULL, then any events that might cause the DPR to `call back' the application will be processed during ISR processing but ignored by the DPR. Table 3: Device Initialization Vector: sTUP_DIV Field Name
valid initMode
Field Type
UINT2 TUP_MODE
Field Description Indicates that this profile is valid Mode used for Initialization: TUP_NORM, TUP_COMP or
TUP_FRM
pinitData
UINT1*
(pointer to) initialization data. Depending on the specified mode of initialization, this is in fact a pointer to sTUP_INIT_DATA_NORM, sTUP_INIT_DATA_COMP or
sTUP_INIT_DATA_FRM
pollISR cbackIO cbackVTPP cbackRTOP cbackRTTB
TUP_POLL sTUP_CBACK sTUP_CBACK sTUP_CBACK sTUP_CBACK
Indicates the type of ISR / polling to do Address for the callback function for IO Events Address for the callback function for VTPP Events Address for the callback function for RTOP Events Address for the callback function for RTTB Events
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
29
Tupp+622 (PM5363) Driver Manual Data Structures
Initialization Profile: INIT_PROF
Initialization Profile Top-Level Structure Passed via the tuppAddInitProfile call, this structure contains all the information needed by the driver to initialize and activate a TUPP+622 device. This is in fact the same structure as
sTUP_DIV.
Table 4: Initialization Profile: sTUP_INIT_PROF Field Name
valid initMode
Field Type
UINT2 TUP_MODE
Field Description Indicates that this profile is valid Mode used for Initialization: TUP_NORM, TUP_COMP or
TUP_FRM
pinitData
UINT1*
(pointer to) initialization data. Depending on the specified mode of initialization, this is in fact a pointer to sTUP_INIT_DATA_NORM, sTUP_INIT_DATA_COMP or
sTUP_INIT_DATA_FRM.
pollISR cbackIO cbackVTPP cbackRTOP cbackRTTB
TUP_POLL sTUP_CBACK sTUP_CBACK sTUP_CBACK sTUP_CBACK
Indicates the type of ISR / polling to do Address for the callback function for IO Events Address for the callback function for VTPP Events Address for the callback function for RTOP Events Address for the callback function for RTTB Events
Initialization Data in Normal Mode (TUP_NORM) In Normal mode (NORM), the user only specifies the main modes of operation of the device. Most of the device's register bits are left in their default state (after a software reset). This structure is pointed to by pinitData inside the initialization profile. Table 5: Initialization Data: sTUP_INIT_DATA_NORM Field Name
au4Mode[4]
Field Type
UINT1
Field Description Selects between AU4 and AU3 mode of operation for the incoming and outgoing data stream
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
30
Tupp+622 (PM5363) Driver Manual Data Structures
Field Name
tug3Mapping[4][3]
Field Type
UINT1
Field Description Selects the type of mapping for the incoming and outgoing data stream. When non-zero, enables processing a TU3 or TUG2s that have been mapped into a TUG3. When zero, enables processing TUG2s that have been mapped into a VC3
tu3Mapping[4][3]
UINT1
Enables processing a single TU3 that have been mapped into a TUG3. Selects between TU2 (VT6) , VT3, TU12 (VT2), and TU11 (VT1.5) mapping for each TUG2 (VTG) by specifying how many tributaries constitute each TUG2 When non-zero, the corresponding AU3 is bypassed by the TUPP+622, the corresponding processors are left in reset.
tug2Mapping[4][3][7]
UINT1
byPass[4][3]
UINT1
Initialization Data in Compatibility Mode (TUP_COMP) In Compatibility mode (COMP), the user provides a list of data blocks to write directly to the device registers. There are numBlocks blocks provided by the user. The block number [i] is fully defined by: * * * *
ppblock[i], which points to the data to write to the device's registers ppmask[i], which points to a data mask to specify which bits are to be modified psize[i], the block size pstartReg[i], which is the register number at which the driver should start writing the
data. This structure is pointed to by pinitData inside the initialization profile. Table 6: Initialization Data: sTUP_INIT_DATA_COMP Field Name
numBlocks ppblk[]
Field Type
UINT2 UINT1*
Field Description Number of provided blocks (pointer to) an array of pointer to a data block
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
31
Tupp+622 (PM5363) Driver Manual Data Structures
Field Name
ppmask[] pblkSize[] pstartReg[]
Field Type
UINT1* UINT2 UINT2
Field Description (pointer to) an array of pointer to a mask (pointer to) an array of block size Array of register numbers
Initialization Data in FRM Mode (TUP_FRM) In Flat Register Mode (FRM), for each of the hardware blocks (IO, VTPP, RTOP and RTTB), the user needs to fill a structure that holds a mapping of all the configuration bits for this hardware block. They are used to fully configure the TUPP+622 device. This structure is pointed to by pinitData inside the initialization profile. The reader is referred to the code for the definitions of the configuration blocks (sTUP_CFG_XXX). Table 7: Initialization Data: sTUP_INIT_DATA_FRM Field Name
au4Mode[4]
Field Type
UINT1
Field Description Selects between AU4 and AU3 mode of operation for the incoming and outgoing data stream Selects the type of mapping for the incoming and outgoing data stream. When non-zero, enables processing a TU3 or TUG2s that have been mapped into a TUG3. When zero, enables processing TUG2s that have been mapped into a VC3
tug3Mapping[4][3]
UINT1
tu3Mapping[4][3]
UINT1
Enables processing a single TU3 that have been mapped into a TUG3 Selects between TU2 (VT6) , VT3, TU12 (VT2), and TU11 (VT1.5) mapping for each TUG2 (VTG) by specifying how many tributaries constitute each TUG2 When non-zero, the corresponding AU3 is bypassed by the TUPP+622, the corresponding processors are left in reset.
tug2Mapping[4][3][7]
UINT1
byPass[4][3]
UINT1
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
32
Tupp+622 (PM5363) Driver Manual Data Structures
Field Name
cfgIO[4] cfgVTPP[4]
Field Type
sTUP_CFG_IO sTUP_CFG_VTPP
Field Description Input/Output (IO) configuration block Tributary Payload Processor (VTPP) configuration block Tributary Path Overhead Processor (RTOP) configuration block Tributary Trace Buffer (RTTB) configuration block
cfgRTOP[4]
sTUP_CFG_RTOP
cfgRTTB[4]
sTUP_CFG_RTTB
ISR Enable/Disable Mask
Passed via the tuppSetMask, tuppGetMask and tuppClearMask calls, this structure contains all the information needed by the driver to enable and disable any of the interrupts in the TUPP+622. Table 8: ISR Mask: sTUP_MASK Field Name
ioIpe[4] lom[4][3] vtppMaster[4][3] rtopMaster[4][3] rttbMaster[4][3] vtppLop[4][3][7][4] vtppNje[4][3][7][4] vtppPje[4][3][7][4] vtppEse[4][3][7][4] vtppAis[4][3][7][4] rtopPslu[4][3][7][4]
Field Type
UINT1 UINT1 UINT1 UINT1 UINT1 UINT1 UINT1 UINT1 UINT1 UINT1 UINT1
Field Description Incoming parity error Loss of Multiframe VTPP master interrupt RTOP master interrupt RTTB master interrupt Loss of pointer Negative pointer justification event. Positive pointer justification event. Elastic store error Path AIS Tributary path signal label unstable
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
33
Tupp+622 (PM5363) Driver Manual Data Structures
Field Name
rtopPslm[4][3][7][4] rtopCopsl[4][3][7][4] rtopRfi[4][3][7][4] rtopRdi[4][3][7][4] rttbTim[4][3][7][4] rttbTiu[4][3][7][4]
Field Type
UINT1 UINT1 UINT1 UINT1 UINT1 UINT1
Field Description Tributary path signal label mismatch Change of tributary path signal label Remote failure indication Remote defect indication Trail trace identifier mismatch Trail trace identifier unstable
Device and Alarm Status
This structure as well as its component structures is used by tuppGetStatus to retrieve all the status information for a given STM1. Table 9: Alarm Status (sTUP_STATUS) Field Name
statIO statVTPP[3] statRTOP[3]
Field Type
sTUP_STATUS_IO sTUP_STATUS_VTPP sTUP_STATUS_RTOP
Field Description Alarm status of the input/output (IO) Alarm status of the Section Overhead (VTPP) Alarm status of the Received Tributary Overhead Processor (RTOP) Alarm status of the Received Tributary Trace Buffer (RTTB)
statRTTB[3]
sTUP_STATUS_RTTB
Input / Output (IO) Status Table 10: Input/Output Status (sTUP_STATUS_IO) Field Name
otmfActiv gsclkfpActiv
Field Type
UINT1 UINT1
Field Description Monitors for low to high transition on the OTMF input Monitors for low to high transition on the GSCLK_FP input
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
34
Tupp+622 (PM5363) Driver Manual Data Structures
Field Name
idActiv
Field Type
UINT1
Field Description Monitors for low to high transition on the input data bus (ID) Monitors for low to high transition on the ITMF input Monitors for low to high transition on the IPL input Monitors for low to high transition on the IC1J1 input Monitors for low to high transition on the SCLK input Monitors for low to high transition on the HSCLK input Monitors for low to high transition on the ITV5 input Monitors for low to high transition on the ITPL input Monitors for low to high transition on the IAIS input
itmfActiv iplActiv ic1j1Activ sclkActiv hsclkActiv itv5Activ itplActiv iaisActiv
UINT1 UINT1 UINT1 UINT1 UINT1 UINT1 UINT1 UINT1
Tributary Payload Processor (VTPP) Status Table 11: VTPP Status (sTUP_STATUS_VTPP) Field Name
ss[7][4]
Field Type
UINT1
Field Description Value of the size bits in the V1 byte of the corresponding tributary
Tributary Path Overhead Processor (RTOP) Status Table 12: RTOP Status (sTUP_STATUS_RTOP) Field Name
expPSL[7][4] accPSL[7][4] rdi[7][4]
Field Type
UINT1 UINT1 UINT1
Field Description Expected Path Signal Label for the corresponding tributary Accepted Path Signal Label for the corresponding tributary Remote Defect Indication
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
35
Tupp+622 (PM5363) Driver Manual Data Structures
Field Name
rfi[7][4] erdi[7][4] pslm[7][4] pslu[7][4]
Field Type
UINT1 UINT1 UINT1 UINT1
Field Description Remote Failure Indication Enhanced Remote Defect Indication Path Signal Label Mistmatch Path Signal Label Unstable
Tributary Trace Buffer (RTTB) Status Table 13: RTTB Status (sTUP_STATUS_RTTB) Field Name
expTraceMsg[7][4] capTraceMsg[7][4] tim[7][4] tiu[7][4]
Field Type
UINT1[64] UINT1[64] UINT1 UINT1
Field Description Expected tributary trace message Captured tributary trace message Trace Identifier Mismatch Trace Identifier Unstable
Statistic Counters: CNT
This structure is used by the statistics collection APIs to retrieve the device counts. The user can call tuppGetCnt to collect all the device counts for a given STM-1. Table 14: Statistic Counters (sTUP_STAT_CNT) Field Name
rtopBip[3][7][4]
Field Type
UINT2
Field Description Number of block interleave parity errors (BIP-8 or BIP-2). Number of remote error indication (REI).
rtopRei[3][7][4]
UINT2
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
36
Tupp+622 (PM5363) Driver Manual Data Structures
Statistic Counter Configuration: CFG_CNT
This structure contains all the fields needed to configure the device counters. It is also passed via the tuppCfgStats function call. Table 15: Counters Config (sTUP_CFG_CNT) Field Name
rtopBlkBip[4][3][7][4]
Field Type
UINT1
Field Description Controls the accumulation of block BIP-8/BIP2 errors. When non-zero, one or more errors in the tributary BIP-8/BIP-2 byte results in a single error accumulated in the error counter. When zero, all errors are accumulated in the error counter.
rtopBlkRei[4][3]
UINT1
Controls the accumulation of REI's in the incoming TU3 stream on a block or bit basis. When non-zero, REI count codes in the range of 1 to 8 are accumulated on a block basis as a single REI event. All other codes are counted zero events. When zero, REI count codes in the range of 1 to 8 are accumulated on a bit basis as a up to 8 REI events. All other codes are counted zero events.
4.3
Structures in Allocated Memory
These structures are defined and used by the driver and are part of the context memory allocated when the driver is opened.
Module Data Block
The MDB is the top-level structure for the module. It contains configuration data about the module level code and pointers to configuration data about the device level codes.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
37
Tupp+622 (PM5363) Driver Manual Data Structures
Table 16: Module Data Block: sTUP_MDB Field Name
errModule valid maxDevs numDevs maxInitProfs stateModule
Field Type
INT4 UINT2 UINT2 UINT2 UINT2 TUP_MOD_STATE
Field Description Global error Indicator for module calls Indicates that this structure has been initialized Maximum number of devices supported Number of devices currently registered Maximum number of initialization profiles Module state; can be one of the following TUP_MOD_START, TUP_MOD_IDLE or
TUP_MOD_READY
pddb
sTUP_DDB *
(array of) Device Data Blocks (DDB) in context memory (array of) initialization profiles
pinitProfs
sTUP_INIT_PROF *
Device Data Block
The DDB is the top-level structure for each device. It contains configuration data about the device level code and pointers to configuration data about device level sub-blocks. Table 17: Device Data Block: sTUP_DDB Field Name
errDevice valid
Field Type
INT4 UINT2
Field Description Global error indicator for device calls Indicates that this structure has been initialized Base address of the device Stores the user's context for the device. It is passed as an input parameter when the driver invokes an application callback Profile number used at initialization
baseAddr usrCtxt
UINT1* sTUP_USR_CTXT
profileNum
UINT2
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
38
Tupp+622 (PM5363) Driver Manual Data Structures
Field Name
stateDevice
Field Type
TUP_DEV_STATE
Field Description Device State; can be one of the following
TUP+START, TUP_PRESENT, TUP_ACTIVE or TUP_INACTIVE
au4Mode[4]
UINT1
Selects between AU4 and AU3 mode of operation for the incoming and outgoing data stream Selects the type of mapping for the incoming and outgoing data stream. When non-zero, enables processing a TU3 or TUG2s that have been mapped into a TUG3. When zero, enables processing TUG2s that have been mapped into a VC3
tug3Mapping[4][3]
UINT1
tu3Mapping[4][3]
UINT1
Enables processing a single TU3 that have been mapped into a TUG3. Selects between TU2 (VT6) , VT3, TU12 (VT2), and TU11 (VT1.5) mapping for each TUG2 (VTG) by specifying how many tributaries constitute each TUG2 When non-zero, the corresponding AU3 is bypassed by the TUPP+622, the corresponding processors are left in reset. Input/Output (IO) configuration block Tributary Payload Processor (VTPP) configuration block Tributary Path Overhead Processor (RTOP) configuration block Tributary Trace Buffer (RTTB) configuration block Indicates the current type of ISR/polling Address for the callback function for IO Events
tug2Mapping[4][3][7]
UINT1
byPass[4][3]
UINT1
cfgIO[4] cfgVTPP[4]
sTUP_CFG_IO sTUP_CFG_VTPP
cfgRTOP[4]
sTUP_CFG_RTOP
cfgRTTB[4]
sTUP_CFG_RTTB
pollISR cbackIO
TUP_POLL sTUP_CBACK
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
39
Tupp+622 (PM5363) Driver Manual Data Structures
Field Name
cbackVTPP
Field Type
sTUP_CBACK
Field Description Address for the callback function for VTPP Events Address for the callback function for RTOP Events Address for the callback function for RTTB Events Interrupt Enable Mask
cbackRTOP
sTUP_CBACK
cbackRTTB
sTUP_CBACK
mask
sTUP_MASK
4.4
Structures Passed Through RTOS Buffers
Interrupt-Service Vector: ISV
This block is used in two ways. First it is used to determine the size of buffer required by the RTOS for use in the driver. Second it is the template for data that is captured during ISR processing and sent to the Deferred-Processing Routine (DPR). Table 18: Interrupt-Service Vector: sTUP_ISV Field Name
deviceHandle mask
Field Type
sTUP_HNDL sTUP_MASK
Field Description Handle to the device in cause ISR mask filled with interrupt status
Deferred-Processing Vector: DPV
This block is used in two ways. First it is used to determine the size of buffer required by the RTOS for use in the driver. Second it is the template for data that is assembled by the DPR and sent to the application code. Note: The application code is responsible for returning this buffer to the RTOS buffer pool.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
40
Tupp+622 (PM5363) Driver Manual Data Structures
Table 19: Deferred-Processing Vector: sTUP_DPV Field Name
event cause
Field Type
TUP_DPR_EVENT UINT2
Field Description Event being reported Reason for the Event
4.5
Global Variable
Most variables within the driver are not meant to be used by the application code. There is one, however, that can be of great use to the application code:
tuppMDB: A global pointer to the Module Data Block (MDB). This global variable is to be
considered read only by the application. *
errModule: This structure element is used to store an error code that specifies the reason for
an API function's failure. The field is only valid when the function in question returns a
TUP_FAILURE value.
* *
stateModule: This structure element is used to store the module state. pddb[ ]: An array of pointers to the individual Device Data Blocks. The user is cautioned that
a DDB is only valid if the `valid' flag is set. Note that the DDBs are in no particular order.
errDevice: this structure element is used to store an error code that specifies the reason
for an API function's failure. The field is only valid when the function in question returns a TUP_FAILURE value.
stateDevice: this structure element is used to store the device state.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
41
Tupp+622 (PM5363) Driver Manual Application Programming Interface
5
APPLICATION PROGRAMMING INTERFACE
This section provides a detailed description of each function that is a member of the TUPP+622 driver Application Programming Interface (API).
5.1
Module Initialization
Opening the Driver Module: tuppModuleOpen
This function performs module level initialization of the device driver. This involves allocating all of the memory needed by the driver and initializing the Module Data Block (MDB) with the passed Module Initialization Vector (MIV). Prototypes Inputs Outputs Returns
INT4 tuppModuleOpen(sTUP_MIV *pmiv) pmiv
: (pointer to) Module Initialization Vector
None Success = TUP_SUCCESS Failure = START Changes MODULE state to IDLE
Valid States Side Effects
Closing the Driver Module: tuppModuleClose
This function performs module level shutdown of the driver. This involves deleting all devices being controlled by the driver (by calling tuppDelete for each device) and de-allocating the MDB. Prototype Inputs Outputs Returns
INT4 tuppModuleClose(void)
None None Success = TUP_SUCCESS Failure = ALL STATES
Valid States
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
42
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Side Effects
Changes MODULE state to START
5.2
Module Activation
Starting the Driver Module: tuppModuleStart
This function performs module level startup of the driver. This involves allocating semaphores and timers, initializing buffers and installing the ISR handler and DPR task. Upon successful return of this function the driver is ready to add devices. Prototype Inputs Outputs Returns
INT4 tuppModuleStart(void)
None None Success = TUP_SUCCESS Failure = IDLE Changes MODULE state to READY
Valid States Side Effects
Stopping the Driver Module: tuppModuleStop
This function performs module level shutdown of the driver. This involves deleting all devices being controlled by the driver and removing the ISR handler and DPR task. Prototype Inputs Outputs Returns
INT4 tuppModuleStop(void)
None None Success = TUP_SUCCESS Failure = < TUPP+622 ERROR CODE> READY Changes MODULE state to IDLE
Valid States Side Effects
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
43
Tupp+622 (PM5363) Driver Manual Application Programming Interface
5.3
Initialization Profile Management
Creating an Initialization Profile: tuppAddInitProfile
This function creates an initialization profile that is stored by the driver. A device can now be initialized by simply passing an initialization profile number. Prototype Inputs
INT4 tuppAddInitProfile(sTUP_INIT_PROF *pProfile, UINT2 *pProfileNum) pProfile pProfileNum
: (pointer to) initialization profile being added : (pointer to) profile number to be assigned by the driver : profile number assigned by the driver
Outputs Returns
profileNum
Success = TUP_SUCCESS Failure = IDLE, READY None
Valid States Side Effects
Retrieving an Initialization Profile: tuppGetInitProfile
This function retrieves the contents of the initialization profile. Prototype Inputs
INT4 tuppGetInitProfile(UINT2 profileNum, sTUP_INIT_PROF *pProfile) profileNum pProfile pProfile
: initialization profile number : (pointer to) initialization profile : contents of the corresponding profile
Outputs Returns
Success = TUP_SUCCESS Failure = IDLE, READY None
Valid States Side Effects
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
44
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Deleting an Initialization Profile: tuppDeleteInitProfile
This function deletes an initialization profile given its profile number. Prototype Inputs Outputs Returns
INT4 tuppDeleteInitProfile(UINT2 profileNum) profileNum
: initialization profile number
None Success = TUP_SUCCESS Failure = IDLE, READY None
Valid States Side Effects
5.4
Device Addition and Deletion
Adding a Device: tuppAdd
This function verifies the presence of a new device in the hardware then returns a handle back to the user. The device handle is passed as a parameter of most of the device API Functions. The handle is used by the driver to identify the device on which the operation is to be performed. Prototype Inputs
sTUP_HNDL tuppAdd(void *usrCtxt, UINT1 *baseAddr, INT4 **perrDevice) usrCtxt baseAddr pperrDevice pperrDevice
: user context for this device : base address of the device : (pointer to) an area of memory : (pointer to) errDevice (inside the DDB)
Outputs Returns Valid States Side Effects
Device handle (to be used as an argument to most of the TUPP+622 APIs) or NULL pointer in case of an error READY Changes the DEVICE state to PRESENT
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
45
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Deleting a Device: tuppDelete
This function is used to remove the specified device from the list of devices being controlled by the TUPP+622 driver. Deleting a device involves clearing the DDB for that device and releasing its associated device handle. Prototype Inputs Outputs Returns
INT4 tuppDelete(sTUP_HNDL deviceHandle) deviceHandle
: device Handle (from tuppAdd)
None Success = TUP_SUCCESS Failure = PRESENT, ACTIVE, INACTIVE None
Valid States Side Effects
5.5
Device Initialization
Initializing a Device: tuppInit
This function initializes the Device Data Block (DDB) that is associated with that device during tuppAdd. It applies a reset to the device and configures it according to the DIV passed by the Application. If the DIV is passed as a NULL the profile number is used. A profile number of zero indicates that all the register bits are to be left in their default state (after a soft reset). Note that the profile number is ignored UNLESS the passed DIV is NULL. Prototype Inputs
INT4 tuppInit(sTUP_HNDL deviceHandle, sTUP_DIV *pdiv, UINT2 profileNum) deviceHandle pdiv profileNum
: device Handle (from tuppAdd) : (pointer to) Device Initialization Vector : profile number (ignored if pdiv is NULL)
Outputs Returns
None Success = TUP_SUCCESS Failure = PRESENT Changes DEVICE state to INACTIVE
Valid States Side Effects
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
46
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Updating the Configuration of a Device: tuppUpdate
This function updates the configuration of the device as well as the Device Data Block (DDB) associated with that device according to the DIV passed by the Application. The only difference between tuppUpdate and tuppInit is that no soft reset will be applied to the device. Prototype Inputs
INT4 tuppUpdate(sTUP_HNDL deviceHandle, sTUP_DIV *pdiv, UINT2 profileNum) deviceHandle pdiv profileNum
: device Handle (from tuppAdd) : (pointer to) Device Initialization Vector : profile number (ignored if pdiv is NULL)
Outputs Returns
None Success = TUP_SUCCESS Failure = PRESENT Changes DEVICE state to INACTIVE
Valid States Side Effects
Resetting a Device: tuppReset
This function applies a software reset to the TUPP+622 device. It also resets all the DDB contents (except for the user context). This function is typically called before re-initializing the device. Prototype Inputs Outputs Returns
INT4 tuppReset(sTUP_HNDL deviceHandle) deviceHandle
: device Handle (from tuppAdd)
None Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE Changes DEVICE state to PRESENT
Valid States Side Effects
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
47
Tupp+622 (PM5363) Driver Manual Application Programming Interface
5.6
Device Activation and De-Activation
Activating a Device: tuppActivate
This function restores the state of a device after it has been deactivated. Interrupts may be reenabled after deactivation. Prototype Inputs Outputs Returns
INT4 tuppActivate(sTUP_HNDL deviceHandle) deviceHandle
: device Handle (from tuppAdd)
None Success = TUP_SUCCESS Failure = INACTIVE Change the device state to ACTIVE
Valid States Side Effects
DeActivating a Device: tuppDeActivate
This function de-activates the device from operation. In the process, interrupts are masked and the device is put into a quiet state via enable bits. Prototype Inputs Outputs Returns
INT4 tuppDeActivate(sTUP_HNDL deviceHandle) deviceHandle
: device Handle (from tuppAdd)
None Success = TUP_SUCCESS Failure = ACTIVE Changes the device state to INACTIVE
Valid States Side Effects
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
48
Tupp+622 (PM5363) Driver Manual Application Programming Interface
5.7
Device Reading and Writing
Reading from a Device Register: tuppRead
This function can be used to read a register of a specific TUPP+622 device by providing the register number. This function derives the actual address location based on the device handle and register number inputs. It then reads the contents of this address location using the system specific macro, sysTuppRead. Note: A failure to read returns a zero and any error indication is written to the DDB. Prototype Inputs
UINT1 tuppRead(sTUP_HNDL deviceHandle, UINT2 regNum) deviceHandle regNum
: device Handle (from tuppAdd) : register number
Outputs Returns
ERROR code written to the DDB Success = the register value Failure = 0x00 All Device States May affect registers that change after a read operation
Valid States Side Effects
Writing to a Device: tuppWrite
This function can be used to write to a register of a specific TUPP+622 device by providing the register number. The function derives the actual address location based on the device handle and register number inputs. It then writes the contents of this address location using the system specific macro sysTuppWrite. Note: A failure to write returns a zero and any error indication is written to the DDB. Prototype Inputs
UINT1 tuppWrite(sTUP_HNDL deviceHandle, UINT2 regNum, UINT1 value) deviceHandle regNum value
: device Handle (from tuppAdd) : register number : value to be written
Outputs Returns
ERROR code written to the DDB Success = previous value Failure = 0x00
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
49
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Valid States Side Effects
All Device States May change the configuration of the Device
Reading a Block of Registers: tuppReadBlock
This function can be used to read a register block of a specific TUPP+622 device by providing the starting register number, and the size to read. The function derives the actual start address location based on the device handle and starting register number inputs. It then reads the contents of this data block using multiple calls to the system specific macro and sysTuppRead. Note: Any error indication is written to the DDB. It is the user's responsibility to allocate enough memory for the block read. Prototype Inputs
void tuppReadBlock(sTUP_HNDL deviceHandle, UINT2 startRegNum, UINT2 size, UINT1 *pblock) deviceHandle startRegNum size pblock
: device Handle (from tuppAdd) : starting register number : size of the block to read : (pointer to) the block to read
Outputs
pblock
ERROR code written to the DDB : (pointer to) the block read None ALL DEVICE STATES May affect registers that change after a read operation
Returns Valid States Side Effects
Writing a Block of Registers: tuppWriteBlock
This function can be used to write to a register block of a specific TUPP+622 device by providing the starting register number and the block size. The function derives the actual starting address location based on the device handle and starting register number inputs. It then writes the contents of this data block using multiple calls to the system specific macro and sysTuppWrite. A bit from the passed block is only modified in the device's registers if the corresponding bit is set in the passed mask. Note: Any error indication is written to the DDB Prototype
void tuppWriteBlock(sTUP_HNDL deviceHandle, UINT2
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
50
Tupp+622 (PM5363) Driver Manual Application Programming Interface
startRegNum, UINT2 size, UINT1 *pblock, UINT1 *pmask)
Inputs
deviceHandle startRegNum size pblock pmask
: device Handle (from tuppAdd) : starting register number : size of block to read : (pointer to) block to write : (pointer to) mask
Outputs Returns Valid States Side Effects
ERROR code written to the DDB None ALL DEVICE STATES May change the configuration of the Device
5.8
Input/Output
Configuring Auto-Responses: tuppAutoResponse
This function configures the per STM1 auto-response behavior of the TUPP+622. The device is optionally configured to automatically insert AIS, RDI or ARDI upon detection of one or more of the following alarms LOM, LOP, AIS, UNEQ, PSLM, PSLU, TIM and TIU. Prototype Inputs
INT4 tuppAutoResponse(sTUP_HNDL deviceHandle, UINT2 stm1, UINT1 ais, UINT1 rdi, UINT1 ardi) deviceHandle stm1 ais
rdi
ardi
: device Handle (from tuppAdd) : STM-1 (STS-3) index : mask to write to STP Tributary Alarm auxiliary AIS Control Register (register 010H) : mask to write to STP Tributary Remote defect Indication Control Register:(register 011H) : mask to write to STP Tributary Auxiliary Remote Defect Indication Control Register: (register 012H)
Outputs Returns
None Success = TUP_SUCCESS Failure =
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
51
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Valid States Side Effects
ACTIVE, INACTIVE None
5.9
Tributary Payload Processor
Configuring Position of the J1 Byte: tuppVTPPConfigJ1
This function configures the position of the J1 byte for a given STM-1 (STS-3). For example, setting posJ1 to a value of zero will force J1 to immediately follow H3, while a value of 522 will force J1 to immediately follow J0/Z0. posJ1 can be set to any value between 0 and 782. Prototype Inputs
INT4 tuppVTPPConfigJ1(sTUP_HNDL deviceHandle, UINT2 stm1, UINT2 posJ1) deviceHandle stm1 posJ1
: device Handle (from tuppAdd) : STM-1 (STS-3) index : J1 position
Outputs Returns
None Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE None
Valid States Side Effects
Inserting all 0s in H4: tuppVTPPSquelchH4
This function enables insertion of an all-zeros byte in the H4 position of the outgoing payload. Prototype Inputs
INT4 tuppVTPPSquelchH4(sTUP_HNDL deviceHandle, UINT2 stm1, UINT2 au3, UINT2 enable) deviceHandle stm1 au3 enable
: device Handle (from tuppAdd) : STM-1 (STS-3) index : AU-3 (STS-1) index : enable zeroing of H4 byte
Outputs
None
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
52
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Returns
Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE None
Valid States Side Effects
Forcing Path AIS: tuppVTPPForcePAIS
This function enables insertion of path AIS in the outgoing payload. Prototype Inputs
INT4 tuppVTPPForcePAIS(sTUP_HNDL deviceHandle, UINT2 stm1, UINT2 au3, UINT2 tug2, UINT2 tu, UINT2 enable) deviceHandle stm1 au3 tug2 tu enable
: device Handle (from tuppAdd) : STM-1 (STS-3) index : AU-3 (STS-1) index : TUG2 (VTG) index : TU (VT) index : enable forcing insertion of path AIS
Outputs Returns
None Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE None
Valid States Side Effects
Forcing Path IDLE: tuppVTPPForceIDLE
This function enables insertion of path IDLE in the outgoing payload. Prototype Inputs
INT4 tuppVTPPForceIDLE(sTUP_HNDL deviceHandle, UINT2 stm1, UINT2 au3, UINT2 tug2, UINT2 tu, UINT2 enable) deviceHandle stm1 au3 tug2 tu enable
: device Handle (from tuppAdd) : STM-1 (STS-3) index : AU-3 (STS-1) index : TUG2 (VTG) index : TU (VT) index : enable forcing insertion of path IDLE
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
53
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Outputs Returns
None Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE None
Valid States Side Effects
Forcing Loss of Pointer: tuppVTPPDiagLOP
This function enables inversion of the new data flag (NDF) field of the outgoing payload pointer to cause downstream pointer processing elements to enter a loss of pointer state. Prototype Inputs
INT4 tuppVTPPDiagLOP(sTUP_HNDL deviceHandle, UINT2 stm1, UINT2 au3, UINT2 tug2, UINT2 tu, UINT2 enable) deviceHandle stm1 au3 tug2 tu enable
: device Handle (from tuppAdd) : STM-1 (STS-3) index : AU-3 (STS-1) index : TUG2 (VTG) index : TU (VT) index : enable
Outputs Returns
None Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE None
Valid States Side Effects
5.10 Tributary Path Overhead Processors
Forcing PDIV Output High: tuppRTOPForcePDIVHigh
This function forces the state of the PDIV output. When enable flag is set, the PDIV output is set high independently of the tributary's defect status. Prototype
INT4 tuppRTOPForcePDIVHigh(sTUP_HNDL deviceHandle, UINT2 stm1, UINT2 au3, UINT2 tug2, UINT2 tu, UINT2
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
54
Tupp+622 (PM5363) Driver Manual Application Programming Interface
enable)
Inputs
deviceHandle stm1 au3 tug2 tu enable
: device Handle (from tuppAdd) : STM-1 (STS-3) index : AU-3 (STS-1) index : TUG2 (VTG) index : TU (VT) index : enable forcing PDIV high
Outputs Returns
None Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE None
Valid States Side Effects
Getting/Setting Path Signal Label: tuppRTOPPathSigLabel
This function gets/sets the path signal label in the Tributary Path Overhead Processor. It is the user's responsibility to make sure that the path signal label pointer points to an area of memory large enough to hold all the data returned. Prototype
INT4 tuppRTOPPathSigLabel(sTUP_HNDL deviceHandle, UINT2 stm1, UINT2 au3, UINT2 tug2, UINT2 tu, UINT2 rw, UINT2 type, UINT1 *psl) deviceHandle stm1 au3 tug2
Inputs
tu
rw type
psl
: device Handle (from tuppAdd) : STM-1 (STS-3) index : AU-3 (STS-1) index : TUG2 (VTG) index : TU (VT) index : read/write flag, write if zero : type of access: 0: accepted path signal label 1: expected path signal label : (pointer to) path signal label : updated path signal label
Outputs Returns
psl
Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE
Valid States
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
55
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Side Effects
None
Configuring Tributary AIS Auto-Responses: tuppAutoResponseTribAIS
This function configures the TUPP+622 to automatically insert AIS on a given TU upon detection of one or more of the following alarms UNEQ, PSLM, PSLU, TIM and TIU, as configured by
tuppAutoResponse.
Prototype
INT4 tuppAutoResponseTribAIS(sTUP_HNDL deviceHandle, UINT2 stm1, UINT2 au3, UINT2 tug2, UINT2 tu, UINT2 enable) deviceHandle stm1 au3 tug2 tu enable
Inputs
: device Handle (from tuppAdd) : STM-1 (STS-3) index : AU-3 (STS-1) index : TUG2 (VTG) index : TU (VT) index : flag to enable/disable AIS insertion
Outputs Returns
None Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE None
Valid States Side Effects
Configuring In-Band Error Reporting: tuppAutoResponseTribIBER
This function enables/disables in-band error reporting of the TUPP+622 for a given TU. Prototype
INT4 tuppAutoResponseTribIBER(sTUP_HNDL deviceHandle, UINT2 stm1, UINT2 au3, UINT2 tug2, UINT2 tu, UINT2 enable) deviceHandle stm1 au3 tug2 tu enable
Inputs
: device Handle (from tuppAdd) : STM-1 (STS-3) index : AU-3 (STS-1) index : TUG2 (VTG) index : TU (VT) index : flag to enable/disable in band error reporting
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
56
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Outputs Returns
None Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE None
Valid States Side Effects
5.11 Tributary Trace Buffer
Getting/Setting Tributary Trace Messages: tuppTributaryTraceMsg
This function Gets or Sets the current tributary trace message (J2) in the Tributary Trace Buffer. It is the user's responsibility to make sure that the message pointer points to an area of memory large enough to hold all the data returned. Prototype
INT4 tuppTributaryTraceMsg(sTUP_HNDL deviceHandle, UINT2 stm1, UINT2 au3, UINT2 tug2, UINT2 tu, UINT2 rw, UINT2 type, UINT1 *pJ2) deviceHandle stm1 au3 tug2 tu rw type
Inputs
pJ2
: device Handle (from tuppAdd) : STM-1 (STS-3) index : AU-3 (STS-1) index : TUG2 (VTG) index : TU (VT) index : read/write flag, write if zero : type of access: 0: captured tributary trace 1: expected tributary trace : (pointer to) the tributary trace message : updated tributary trace message
Outputs Returns
pJ2
Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE None
Valid States Side Effects
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
57
Tupp+622 (PM5363) Driver Manual Application Programming Interface
5.12 Interrupt Service Functions
Getting the Interrupt Mask: tuppGetMask
This function returns the contents of the interrupt mask registers of the TUPP+622 device. Prototype Inputs
INT4 tuppGetMask(sTUP_HNDL deviceHandle, sTUP_MASK *pmask) deviceHandle pmask
: device Handle (from tuppAdd) : (pointer to) mask structure
Outputs Returns
ERROR code written to the DDB Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE None
Valid States Side Effects
Setting the Interrupt Mask: tuppSetMask
This function sets the contents of the interrupt mask registers of the TUPP+622 device. Prototype Inputs
INT4 tuppSetMask(sTUP_HNDL deviceHandle, sTUP_MASK *pmask) deviceHandle pmask
: device Handle (from tuppAdd) : (pointer to) mask structure
Outputs Returns
ERROR code written to the DDB Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE May change the operation of the ISR / DPR
Valid States Side Effects
Clearing the Interrupt Mask: tuppClearMask
This function clears the individual interrupt bits and registers in the TUPP+622 device. Any bits that are set in the passed structure are cleared in the associated registers.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
58
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Prototype Inputs
INT4 tuppClearMask(sTUP_HNDL deviceHandle, sTUP_MASK *pmask) deviceHandle pmask
: device Handle (from tuppAdd) : (pointer to) mask structure
Outputs Returns
ERROR code written to the DDB Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE May change the operation of the ISR / DPR
Valid States Side Effects
Polling Interrupt Status Registers: tuppPoll
This function commands the driver to poll the interrupt registers in the device. The call will fail unless the device is initialized into polling mode. An additional parameter is available that starts automatic polling on one second boundaries. The output of the poll is the same as it would be if interrupts were enabled: the data gathered is passed to the DPR for disposition. Prototype Inputs Outputs Returns
INT4 tuppPoll(sTUP_HNDL deviceHandle) deviceHandle
: device Handle (from tuppAdd)
None Success = TUP_SUCCESS Failure = ACTIVE None
Valid States Side Effects
Interrupt-Service Routine: tuppISR
This function reads the state of the interrupt registers in the TUPP+622 and stores them into an ISV. It performs whatever functions are needed to clear the interrupt. This routine is called by the application code from within sysTuppISRHandler. Prototype
void * tuppISR(sTUP_HNDL deviceHandle)
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
59
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Inputs Outputs Returns Valid States Side Effects
deviceHandle
: device Handle (from tuppAdd)
None (pointer to) ISV buffer if any valid interrupt condition was found ACTIVE None
Deferred-Processing Routine: tuppDPR
This function acts on data contained in an ISV. It creates a DPV that invokes application code callbacks (if defined and enabled), and possibly other performing linked actions. This function is called from within the application function sysTuppDPRTask. Prototype Inputs Outputs Returns Valid States Side Effects
void tuppDPR(sTUP_ISV *pisv) pisv
: (pointer to) ISV buffer
None None ACTIVE None
5.13 Alarm, Status and Statistics Functions
Configuring Statistical Counts: tuppCfgStats
This function configures the behavior of the device counts. Prototype Inputs
INT4 tuppCfgStats(sTUP_HNDL deviceHandle, sTUP_CFG_CNT cfgCnt) deviceHandle cfgCnt
: device Handle (from tuppAdd) : counters configuration block
Outputs
None
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
60
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Returns
Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE None
Valid States Side Effects
Getting the Current Status: tuppGetStatus
This function retrieves all the device and alarm status for a given STM-1. Note: It is the user's responsibility to ensure that the structure points to an area of memory large enough to hold a copy of the status structure. Prototype Inputs
INT4 tuppGetStatus(sTUP_HNDL deviceHandle, UINT2 stm1, sTUP_STATUS *palm) deviceHandle stml palm palm
: device Handle (from tuppAdd) : STM-1 (STS-3) index : (pointer to) allocated memory : updated status structure for this STM-1
Outputs Returns
Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE None
Valid States Side Effects
Reading the Device Counters: tuppGetCnt
This function retrieves all the device counts for a given STM-1. Note: It is the user's responsibility to ensure that the structure points to an area of memory large enough to hold a copy of the counter structure. Prototype Inputs
INT4 tuppGetCnt(sTUP_HNDL deviceHandle, UINT2 stm1, sTUP_STAT_CNT *pcnt) deviceHandle stml pcnt
: device Handle (from tuppAdd) : STM-1 (STS-3) index : (pointer to) allocated memory
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
61
Tupp+622 (PM5363) Driver Manual Application Programming Interface
Outputs Returns
pcnt
: updated count structure for this STM-1
Success = TUP_SUCCESS Failure = ACTIVE, INACTIVE None
Valid States Side Effects
5.14 Device Diagnostics
Verifying Register Access: tuppTestReg
This function verifies the hardware access to the device registers by writing and reading back values. Prototype Inputs Outputs Returns
INT4 tuppTestReg(sTUP_HNDL deviceHandle) deviceHandle
: device Handle (from tuppAdd)
None Success = TUP_SUCCESS Failure = PRESENT, INACTIVE None
Valid States Side Effects
5.15 Callback Functions
The TUPP+622 driver has the capability to callback to functions within the user code when certain events occur. These events and their associated callback routine declarations are detailed below. There is no user code action that is required by the driver for these callbacks - the user is free to implement these callbacks in any manner or else they can be deleted from the driver.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
62
Tupp+622 (PM5363) Driver Manual Application Programming Interface
IO Section Callbacks: cbackTuppIO
This function is provided by the user and is used by the DPR to report significant IO section events back to the application. This function should be non-blocking. Typically, the callback routine sends a message to another task with the event identifier and other context information. The task that receives this message can then process this information according to the system requirements. The user should free the DPV buffer. Prototype Inputs
void cbackTuppIO(sTUP_USR_CTXT usrCtxt, sTUP_DPV *pdpv) usrCtxt pdpv
: user context (from tuppAdd) : (pointer to) formatted event buffer
Outputs Returns Valid States Side Effects
None None ACTIVE None
VTPP Section Callbacks: cbackTuppVTPP
This function is used by the DPR to report significant VTPP section events back to the application. This function should be non-blocking. Typically, the callback routine sends a message to another task with the event identifier and other context information. The task that receives this message can then process this information according to the system requirements. The user should free the DPV buffer. Prototype Inputs
void cbackTuppVTPP(sTUP_USR_CTXT usrCtxt, sTUP_DPV *pdpv) usrCtxt pdpv
: user context (from tuppAdd) : (pointer to) formatted event buffer
Outputs Returns Valid States Side Effects
None None ACTIVE None
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
63
Tupp+622 (PM5363) Driver Manual Application Programming Interface
RTOP Section Callbacks: cbackTuppRTOP
This function is used by the DPR to report significant RTOP section events back to the application. This function should be non-blocking. Typically, the callback routine sends a message to another task with the event identifier and other context information. The task that receives this message can then process this information according to the system requirements. The user should free the DPV buffer. Prototype Inputs
void cbackTuppRTOP(sTUP_USR_CTXT usrCtxt, sTUP_DPV *pdpv) usrCtxt pdpv
: user context (from tuppAdd) : (pointer to) formatted event buffer
Outputs Returns Valid States Side Effects
None None ACTIVE None
RTTB Section Callbacks: cbackTuppRTTB
This function is used by the DPR to report significant RTTB section events back to the application. This function should be non-blocking. Typically, the callback routine sends a message to another task with the event identifier and other context information. The task that receives this message can then process this information according to the system requirements. The user should free the DPV buffer. Prototype Inputs
void cbackTuppRTTB(sTUP_USR_CTXT usrCtxt, sTUP_DPV *pdpv) usrCtxt pdpv
: user context (from tuppAdd) : (pointer to) formatted event buffer
Outputs Returns Valid States Side Effects
None None ACTIVE None
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
64
Tupp+622 (PM5363) Driver Manual Hardware Interface
6
HARDWARE INTERFACE
The TUPP+622 driver interfaces directly with the user's hardware. In this section, a listing of each point of interface is shown, along with a declaration and any specific porting instructions. It is the responsibility of the user to connect these requirements into the hardware, either by defining a macro or by writing a function for each item listed. Care should be taken when matching parameters and return values.
6.1
Device I/O
Reading Registers: sysTuppRead
This function serves as the most basic hardware connection by reading the contents of a specific register location. This Macro should be UINT1 oriented, and should be defined by the user to reflect the target system's addressing logic. There is no need for error recovery in this function. Prototype Inputs Outputs Returns Format
UINT1 sysTuppRead(addr) addr
: register location to be read
None value read from the addressed register location
#define sysTuppRead(addr)
Writing Values: sysTuppWrite
This function serves as the most basic hardware connection by writing the supplied value to the specific register location. This macro should be UINT1 oriented and should be defined by the user to reflect the target system's addressing logic. There is no need for error recovery in this function. Prototype Inputs Outputs Returns Format
void sysTuppWrite(addr, value) addr
: register location to be read
None value read from the addressed register location
#define sysTuppWrite(addr, value)
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
65
Tupp+622 (PM5363) Driver Manual Hardware Interface
6.2
Interrupt Servicing
The porting of an ISR routine between platforms is a rather difficult task. There are many different implementations of these hardware level routines. In this driver, the user is responsible for installing an interrupt handler (sysTuppISRHandler) in the interrupt vector table of the system processor. This handler shall call tuppISR for each device that has interrupt servicing enabled, to perform the ISR related housekeeping required by each device. During execution of the API function tuppModuleStart / tuppModuleStop the driver informs the application that it is time to install / uninstall this shell via sysTuppISRHandlerInstall / sysTuppISRHandlerRemove, that needs to be supplied by the user. Note: A device can be initialized with ISR disabled. In that mode, the user should periodically invoke a provided `polling' routine (tuppPoll) that in turn calls tuppISR.
Installing the ISR Handler: sysTuppISRHandlerInstall
This function installs the user-supplied Interrupt-Service Routine (ISR), sysTuppISRHandler, into the processor's interrupt vector table. Prototype Inputs Outputs Returns Valid States Format
void sysTuppISRHandlerInstall(void *func) func
: (pointer to) the function tuppISR
None None None
#define sysTuppISRHandlerInstall(func)
ISR Handler: sysTuppISRHandler
This routine is invoked when one or more TUPP+622 devices raise the interrupt line to the microprocessor. This routine invokes the driver-provided routine (tuppISR) for each device registered with the driver. Prototype Inputs Outputs
void sysTuppISRHandler(void)
None None
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
66
Tupp+622 (PM5363) Driver Manual Hardware Interface
Returns Format
None
#define sysTuppISRHandler()
Removing Handlers: sysTuppISRHandlerRemove
This function disables Interrupt processing for this device. It removes the user-supplied InterruptService Routine (ISR), sysTuppISRHandler, from the processor's interrupt vector table. Prototype Inputs Outputs Returns Format
void sysTuppISRHandlerRemove(void)
None None None
#define sysTuppISRHandlerRemove()
DPR Task: sysTuppDPRTask
This routine is installed as a separate task within the RTOS. It runs periodically and retrieves the interrupt status information sent to it by the tuppISRHandler routine, thereafter invoking the tuppDPR routine for the appropriate device. Prototype Inputs Outputs Returns Format
void sysTuppDPRTask(void)
None None None
#define sysTuppDPRTask()
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
67
Tupp+622 (PM5363) Driver Manual RTOS Interface
7
RTOS INTERFACE
The TUPP+622 driver requires the use of some RTOS resources. In this section, a listing of each required resource is shown, along with a declaration and any specific porting instructions. It is the responsibility of the user to connect these requirements into the RTOS, either by defining a macro or writing a function for each item listed. Care should be taken when matching parameters and return values.
7.1
Memory Allocation / De-Allocation
Allocating Memory: sysTuppMemAlloc
This function allocates specified number of bytes of memory. Prototype Inputs Outputs Returns
UINT1 *sysTuppMemAlloc(UINT4 numBytes) numBytes
: number of bytes to be allocated
None Success = Pointer to first byte of allocated memory Failure = NULL pointer (memory allocation failed)
#define sysTuppMemAlloc(numBytes)
Format
Freeing Memory: sysTuppMemFree
This function frees the memory allocated when using the sysTuppMemAlloc. Prototype Inputs
void sysTuppMemFree(UINT1 *pfirstByte) pfirstByte
: pointer to first byte of the memory region being de-allocated
Outputs Returns Format
None None
#define sysTuppMemFree(pfirstByte)
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
68
Tupp+622 (PM5363) Driver Manual RTOS Interface
7.2
Buffer Management
All operating systems provide some sort of buffer system, particularly for use in sending and receiving messages. The following calls, provided by the user, allow the driver to Get and Return buffers from the RTOS. It is the user's responsibility to create any special resources or pools to handle buffers of these sizes during the sysTuppBufferStart call.
Starting Buffer Management: sysTuppBufferStart
This function alerts the RTOS that the ISV buffers and DPV buffers are available and should be sized correctly. This may or may not involve the creation of new buffer pools, depending on the RTOS. Prototype Inputs Outputs Returns
INT4 sysTuppBufferStart(void)
None None Success = 0 Failure = any other value
#define sysTuppBufferStart()
Format
Getting DPV Buffers: sysTuppDPVBufferGet
This function retrieves a buffer from the RTOS. The buffer is used by the DPR code to create a Deferred-Processing Vector (DPV). The DPV contains information about the state of the device. This information is passed on to the user via a callback function. Prototype Inputs Outputs Returns Format
sTUP_DPV *sysTuppDPVBufferGet(void)
None None Success = (pointer to) a DPV buffer Failure = NULL (pointer)
#define sysTuppDPVBufferGet()
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
69
Tupp+622 (PM5363) Driver Manual RTOS Interface
Getting ISV Buffers: sysTuppISVBufferGet
This function retrieves a buffer from the RTOS. The buffer is used by the ISR code to create a Interrupt-Service Vector (ISV). The ISV contains data transferred from the devices interrupt status registers. Prototype Inputs Outputs Returns Format
sTUP_ISV *sysTuppISVBufferGet(void)
None None Success = (pointer to) a ISV buffer Failure = NULL (pointer)
#define sysTuppISVBufferGet()
Returning DPV Buffers: sysTuppDPVBufferRtn
This device returns a DPV buffer to the RTOS when the information in the block is no longer needed by the DPR. Prototype Inputs Outputs Returns Format
void sysTuppDPVBufferRtn(sTUP_DPV *pdpv) pdpv
: (pointer to) a DPV buffer
None None
#define sysTuppDPVBufferRtn(pdpv)
Returning ISV Buffers: sysTuppISVBufferRtn
This device returns a ISV buffer to the RTOS when the information in the block is no longer needed by the DPR. Prototype Inputs Outputs Returns
void sysTuppISVBufferRtn(sTUP_ISV *pisv) pisv
: (pointer to) a ISV buffer
None None
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
70
Tupp+622 (PM5363) Driver Manual RTOS Interface
Format
#define sysTuppISVBufferRtn(pisv)
Stopping Buffer Management: sysTuppBufferStop
This function alerts the RTOS that the driver no longer needs the ISV buffers or DPV buffers. If any special resources were created to handle these buffers, they can be deleted at this time. Prototype Inputs Outputs Returns Format
void sysTuppBufferStop(void)
None None None
#define sysTuppBufferStop()
7.3
Preemption
Disabling Preemption: sysTuppPreemptDisable
This routine prevents the calling task from being preempted. If the driver is in interrupt mode, this routine locks out all interrupts as well as other tasks in the system. If the driver is in polling mode, this routine only locks out the other tasks. Prototype Inputs Outputs Returns
INT4 sysTuppPreemptDisable(void)
None None Preemption key (passed back as an argument in
sysTuppPreemptEnable)
Format
#define sysTuppPreemptDisable()
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
71
Tupp+622 (PM5363) Driver Manual RTOS Interface
Re-Enabling Preemption: sysTuppPreemptEnable
This routine allows the calling task to be preempted. If the driver is in interrupt mode, this routine unlocks all interrupts and other tasks in the system. If the driver is in polling mode, this routine only unlocks the other tasks. Prototype Inputs Outputs Returns Format
void sysTuppPreemptEnable(INT4 key) key
: preemption key (returned by sysTuppPreemptDisable)
None None
#define sysTuppPreemptEnable(key)
7.4
Timers
Suspending a Task Execution: sysTuppTimerSleep
This function suspends the execution of a driver task for a specified number of milliseconds. Prototype Inputs Outputs Returns Format
void sysTuppTimerSleep(UINT4 msec) msec
: sleep time in milliseconds
None None
#define sysTuppTimerSleep(msec)
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
72
Tupp+622 (PM5363) Driver Manual Porting Drivers
8
PORTING DRIVERS
This section outlines how to port the TUPP+622 device driver to your hardware and OS platform. However, this manual can offer only guidelines for porting the TUPP+622 driver because each platform and application is unique.
8.1
Driver Source Files
The C files listed in the following table contain the code for the TUPP+622 driver. You may need to modify the code or develop additional code. The code is in the form of constants, macros, and functions. For ease of porting, the code is grouped into source files (src) and includes files (inc). The source files contain the functions and the include files contain the structures, constants and macros. Directory
src
File
tup_api1.c
Description All API functions that take care of module, device and profile management All TUPP+622 specific API functions. Hardware interface functions Internal functions that deal with interrupt servicing Internal functions that deal with profiles RTOS interface functions Internal functions that deal with statistics All the remaining internal functions All API headers Driver macros, constants and definitions (such as register mapping and bit masks) TUPP+622 error codes Prototype of non-API functions HW interface macros and prototype RTOS interface macros and prototypes
tup_api2.c tup_hw.c tup_isr.c tup_prof.c tup_rtos.c tup_stat.c tup_util.c inc tup_api.h tup_defs.h
tup_err.h tup_fns.h tup_hw.h tup_rtos.h
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
73
Tupp+622 (PM5363) Driver Manual Porting Drivers
Directory
inc
File
tup_strs.h tup_typs.h
Description Driver structures Types definitions Sample driver callback functions Prototypes, macros and structures used inside the example code Functions to implement a debug diagnostic task Prototypes and structures used inside the debug task code
example
tup_app.c tup_app.h
tup_debug.c tup_debug.h
8.2
Driver Porting Procedures
The following procedures summarize how to port the TUPP+622 driver to your platform. The subsequent sections describe these procedures in more detail. To port the TUPP+622 driver to your platform: Step 1: Port the driver's RTOS interface (page 75): Step 2: Port the driver's hardware interface (page 76): Step 3: Port the driver's application-specific elements (page 77): Step 4: Build the driver (page 77). Porting Assumptions The following porting assumptions have been made: * * * It is assumed that RAM assigned to the driver's static variables is initialized to ZERO before any driver function is called. It is assumed that a RAM stack of 4K is available to all of the driver's non-ISR functions and that a RAM stack of 1K is available to the driver's ISR functions. It is assumed that there is no memory management or MMU in the system or that all accesses by the driver, to memory or hardware can be direct.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
74
Tupp+622 (PM5363) Driver Manual Porting Drivers
Step 1: Porting the RTOS interface
The RTOS interface functions and macros consist of code that is RTOS dependent and needs to be modified as per your RTOS' characteristics. To port the driver's OS extensions: 1. Redefine the following macros and functions in the tup_rtos.h file to the corresponding system calls that your target system supports: Service Type Memory Macro Name
sysTuppMemAlloc sysTuppMemFree sysTuppMemCpy
Description Allocates a memory block Frees a memory block Copies the contents of one memory block to another Fills a memory block with a specified value Delays the task execution for a given number of milliseconds Disables pre-emption of the currently executing task by any other task or interrupt Re-enables pre-emption of a task by other tasks and/or interrupts
sysTuppMemSet
Timer
sysTuppTimerSleep
Pre-emption Lock/Unlock
sysTuppPreemptDisable
sysTuppPreemptEnable
2. Modify the example implementation of the buffer management routines provided in the tup_rtos.h file with the corresponding system calls that your target system supports: Service Type Buffer Macro Name
sysTuppBufferStart sysTuppBufferStop sysTuppISVBufferGet sysTuppISVBufferRtn sysTuppDPVBufferGet sysTuppDPVBufferRtn
Description Starts buffer management Stops buffer management Gets an ISV buffer from the ISV buffer queue Returns an ISV buffer to the ISV buffer queue Gets a DPV buffer from the DPV buffer queue Returns a DPV buffer to the DPV buffer queue
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
75
Tupp+622 (PM5363) Driver Manual Porting Drivers
3. Define the following constants for your OS-specific services in tup_rtos.h: Task Constant
TUP_DPR_TASK_PRIORITY TUP_DPR_TASK_STACK_SZ TUP_MAX_ISV_BUF
Description Deferred Task (DPR) task priority DPR task stack size, in bytes
Default 85 8192
The queue message depth of the queue used for pass 50 interrupt context between the ISR task and DPR task The queue message depth of the queue used for pass 950 interrupt context between the ISR task and DPR task
TUP_MAX_DPV_BUF
Step 2: Porting the Hardware Interface
This section describes how to modify the TUPP+622 driver for your hardware platform. To port the driver to your hardware platform: 1. Modify the variable type definitions in tup_typs.h. 2. Modify the low-level hardware-dependent functions and macros in the tup_hw.h file. You may need to modify the raw read/write access macros (sysTuppRead and sysTuppWrite) to reflect your system's addressing logic. Service Type Register Access Function Name
sysTuppRead
Description Reads a device register given its real address in memory Writes to a device register given its real address in memory Installs the interrupt handler for the OS Removes the interrupt handler from the OS Interrupt handler for the TUPP+622 device Task that calls the TUPP+622 DPR
sysTuppWrite
Interrupt
sysTuppISRHandlerInstall sysTuppISRHandlerRemove
sysTuppISRHandler
sysTuppDPRTask
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
76
Tupp+622 (PM5363) Driver Manual Porting Drivers
3. Define the hardware system-configuration constants in the tup_hw.h file. Modify the following constants to reflect your system's hardware configuration: Device Constant
TUP_MAX_DELAY TUP_MAX_POLL
Description Delay between two consecutive polls of a busy bit Maximum number of times a busy bit will be polled before the operation times out
Default 100us 100
Step 3: Porting the Application-Specific Elements
Porting the application-specific elements includes coding the application callback and defining all the constants used by the API. To port the driver's application-specific elements: 1. Modify the base value of TUP_ERR_BASE (default = -300) in tup_err.h. 2. Define the following constants for your OS-specific services in tup_rtos.h: Task Constant
TUP_MAX_DEVS
Description The maximum number of TUPP+622 devices that can be supported by the driver The maximum number of initialization profiles that can be added to the driver
Default 24
TUP_MAX_INIT_PROFS
5
3. Code the callback functions according to your application. Example implementations of these callbacks are provided in app.c. The driver will call these callback functions when an event occurs on the device. These functions must conform to the following prototype:
void cbackXX (sTUP_USR_CTXT usrCtxt, sTUP_DPV *pdpv)
Step 4: Building the Driver
This section describes how to build the TUPP+622 driver. To build the driver: 1. Modify the Makefile to reflect the absolute path of your code, your compiler and compiler options.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
77
Tupp+622 (PM5363) Driver Manual Porting Drivers
2. Choose from among the different compile options supported by the driver as per your requirements. 3. Compile the source files and build the TUPP+622 API driver library using your make utility. 4. Link the TUPP+622 API driver library to your application code.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
78
Tupp+622 (PM5363) Driver Manual Appendix A: Driver Return Codes
APPENDIX A: DRIVER RETURN CODES
Table 20 describes the driver's return codes. Table 20: Return Codes Return Type
TUP_ERR_MEM_ALLOC TUP_ERR_INVALID_ARG TUP_ERR_INVALID_MODULE_STATE TUP_ERR_INVALID_MIV TUP_ERR_PROFILES_FULL TUP_ERR_INVALID_PROFILE TUP_ERR_INVALID_PROFILE_MODE TUP_ERR_INVALID_PROFILE_NUM TUP_ERR_INVALID_DEVICE_STATE TUP_ERR_DEVS_FULL TUP_ERR_DEV_ALREADY_ADDED TUP_ERR_INVALID_DEV TUP_ERR_INVALID_DIV TUP_ERR_INT_INSTALL TUP_ERR_INVALID_MODE TUP_ERR_INVALID_REG TUP_ERR_POLL_TIMEOUT
Description Memory allocation failure Invalid argument Invalid module state Invalid Module Initialization Vector Maximum number of profiles already added Invalid profile Invalid profile mode selected Invalid profile number Invalid device state Maximum number of devices already added Device already added Invalid device handle Invalid Device Initialization Vector Error while installing interrupts Invalid ISR/polling mode Invalid register number Time-out while polling
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
79
Tupp+622 (PM5363) Driver Manual Appendix B: Coding Conventions
APPENDIX B: CODING CONVENTIONS
This section describes the coding conventions used in the implementation of the TUPP+622 driver software.
Variable Type Definitions
Table 21: Variable Type Definitions Type
UINT1 UINT2 UINT4 INT1 INT2 INT4
Description unsigned integer - 1 byte unsigned integer - 2 bytes unsigned integer - 4 bytes signed integer - 1 byte signed integer - 2 bytes signed integer - 4 bytes
Naming Conventions
Table 22 presents a summary of the naming conventions followed by the TUPP+622 driver software. A detailed description is then given in the following sub-sections. The names used in the drivers are verbose enough to make their purpose fairly clear. This makes the code more readable. Generally, the device name or abbreviation appears in prefix. Table 22: Naming Conventions Type Macros Case Uppercase Naming convention Prefix with "m" and device abbreviation Prefix with device abbreviation Examples
mTUP_IO_OFFSET
Constants
Uppercase
TUP_REG_OFFSET_NEXT_STM1
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
80
Tupp+622 (PM5363) Driver Manual Appendix B: Coding Conventions
Type Structures
Case Hungarian Notation Hungarian Notation Hungarian Notation Hungarian Notation Hungarian Notation Hungarian Notation Hungarian Notation
Naming convention Prefix with "s" and device abbreviation Prefix with device name
Examples
sTUP_DDB
API Functions
tuppAdd()
Porting Functions
Prefix with "sys" and device name
sysTuppRead()
Other Functions
utilTuppResetDev()
Variables
maxDevs
Pointers to variables Global variables
Prefix variable name with "p" Prefix with device name
pmaxDevs
tuppMdb
Macros
The following list identifies the macro conventions used in the driver code: * * * * Macro names can be uppercase. Words can be separated by an underscore. The letter `m' in lowercase is used as a prefix to specify that it is a macro, then the device abbreviation appears. Example: mTUP_IO_OFFSET is a valid name for a macro.
Constants
The following list identifies the constant conventions used in the driver code: * * * * Constant names can be uppercase. Words can be separated by an underscore. The device abbreviation can appear as a prefix. Example: TUP_REG_OFFSET_NEXT_STM1 is a valid name for a constant.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
81
Tupp+622 (PM5363) Driver Manual Appendix B: Coding Conventions
Structures
The following list identifies the structure conventions used in the driver code: * * * * Structure names can be uppercase. Words can be separated by an underscore. The letter `s' in lowercase can be used as a prefix to specify that it is a structure, then the device abbreviation appears. Example: sTUP_DDB is a valid name for a structure.
Functions
API Functions * * * Naming of the API functions follows the hungarian notation. The device's full name in all lowercase can be used as a prefix. Example: tuppAdd() is a valid name for an API function.
Porting Functions Porting functions correspond to all function that are HW and/or RTOS dependent. * * * * Naming of the porting functions follows the hungarian notation. The `sys' prefix can be used to indicate a porting function. The device's name starting with an uppercase can follow the prefix. Example: sysTuppRead() is a hardware / RTOS specific.
Other Functions * * Other Functions are all the remaining functions that are part of the driver and have no special naming convention. However, they can follow the hungarian notation. Example: utilTuppResetDev() is a valid name for such a function.
Variables
* * Naming of variables follows the hungarian notation. A pointer to a variable shall use `p' as a prefix followed by the variable name unchanged. If the variable name already starts with a `p', the first letter of the variable name may be capitalized, but this is not a requirement. Double pointers might be prefixed with `pp', but this is not required. Global variables are identified with the device's name in all lowercase as a prefix. Examples: maxDevs is a valid name for a variable, pmaxDevs is a valid name for a pointer to maxDevs, and tuppMdb is a valid name for a global variable.
82
* *
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
Tupp+622 (PM5363) Driver Manual Appendix B: Coding Conventions
*
Note: Both pprevBuf and pPrevBuf are accepted names for a pointer to the prevBuf variable, and that both pmatrix and ppmatrix are accepted names for a double pointer to the variable matrix.
File Organization
Table 23 presents a summary of the file naming conventions. All file names must start with the device abbreviation, followed by an underscore and the actual file name. File names should convey their purpose with a minimum amount of characters. If a file size is getting too big one might separate it into two or more files, providing that a number is added at the end of the file name (e.g. tup_api1.c or tup_api2.c). There are 4 different types of files: * * * * The API file containing all the API functions The hardware file containing the hardware dependent functions The RTOS file containing the RTOS dependent functions The other files containing all the remaining functions of the driver
Table 23: File Naming Conventions File Type API Hardware Dependent RTOS Dependent Other File Name
tup_api1.c, tup_api.h tup_hw.c, tup_hw.h tup_rtos.c, tup_rtos.h tup_isr.c, tup_defs.h
API Files
* * The name of the API files starts with the device abbreviation followed by an underscore and `api'. For more than one API file, a number is appended to the file name. Examples: tup_api1.c is the only valid name for the file that contains the first part of the API functions; tup_api.h is the only valid name for the file that contains all of the API functions headers.
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
83
Tupp+622 (PM5363) Driver Manual Appendix B: Coding Conventions
Hardware Dependent Files
* The name of the hardware dependent files starts with the device abbreviation followed by an underscore and `hw'. For more than one hardware dependent file, a number is appended to the file name. Examples: tup_hw.c is the only valid name for the file that contains all of the hardware dependent functions; tup_hw.h is the only valid name for the file that contains all of the hardware dependent functions headers.
*
RTOS Dependent Files
* The name of the RTOS dependent files starts with the device abbreviation followed by an underscore and `rtos'. For more than one RTOS dependent file, a number is appended to the file name. Examples: tup_rtos.c is the only valid name for the file that contains all of the RTOS dependent functions; tup_rtos.h is the only valid name for the file that contains all of the RTOS dependent functions headers.
*
Other Driver Files
* The name of the remaining driver files must start with the device abbreviation followed by an underscore and the file name itself, which should convey the purpose of the functions within that file with a minimum amount of characters. Examples: tup_isr.c is a valid name for a file that would deal with interrupt servicing, tup_defs.h is a valid name for the header file that contains all the driver's definitions.
*
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
84
Tupp+622 (PM5363) Driver Manual
ACRONYMS
API: Application Programming Interface DDB: Device Data Block DIV: Device Initialization Vector DPR: Deferred-Processing Routine DPV: Deferred-Processing (routine) Vector FIFO: First In, First Out IO: Input/Output ISR: Interrupt-Service Routine ISV: Interrupt-Service (routine) Vector MDB: Module Data Block MIV: Module Initialization Vector RTOP: Tributary Path Overhead Processor RTOS: Real-Time Operating System RTTB: Tributary Trace Buffer VTPP: Tributary Payload Processor
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
85
Tupp+622 (PM5363) Driver Manual
LIST OF TERMS
APPLICATION: Refers to protocol software used in a real system as well as validation software written to validate the TUPP+622 driver on a validation platform. API (Application Programming Interface): Describes the connection between this module and the user's Application code. ISR (Interrupt-Service Routine): A common function for intercepting and servicing device events. This function is kept as short as possible because an Interrupt preempts every other function starting the moment it occurs and gives the service function the highest priority while running. Data is collected, Interrupt indicators are cleared and the function ended. DPR (Deferred-Processing Routine): This function is installed as a task, at a user configurable priority, that serves as the next logical step in Interrupt processing. Data that was collected by the ISR is analyzed and then calls are made into the Application that inform it of the events that caused the ISR in the first place. Because this function is operating at the task level, the user can decide on its importance in the system, relative to other functions. DEVICE: One TUPP+622 Integrated Circuit. There can be many devices, all served by this one driver module * DIV (Device Initialization Vector): Structure passed from the API to the device during initialization; it contains parameters that identify the specific modes and arrangements of the physical device being initialized. DDB (Device Data Block): Structure that holds the Configuration Data for each device.
*
MODULE: All of the code that is part of this driver, there is only one instance of this module connected to one or more TUPP+622 chips. * MIV (Module Initialization Vector): Structure passed from the API to the module during initialization, it contains parameters that identify the specific characteristics of the driver module being initialized. MDB (Module Data Block): Structure that holds the Configuration Data for this module.
*
RTOS (Real-Time Operating System): The host for this driver
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
86
Tupp+622 (PM5363) Driver Manual
INDEX
A
api functions
tuppActivate-7, 52 tuppAdd-6, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 91, 92 tuppAddInitProfile-6, 30, 31, 48 tuppAutoResponse-7, 56, 61 tuppAutoResponseTribAIS-7, 61 tuppAutoResponseTribIBER-7, 62 tuppCfgStats-7, 40, 67 tuppClearMask-7, 36, 65 tuppDeActivate-7, 53 tuppDelete-6, 26, 46, 50 tuppDeleteInitProfile-6, 49 tuppDPR-5, 7, 20, 25, 26, 27, 66, 74 tuppGetCnt-2, 3, 7, 39, 68 tuppGetInitProfile-6, 48 tuppGetMask-7, 36, 64 tuppGetStatus-2, 3, 7, 37, 67 tuppInit-6, 30, 51 tuppISR-5, 7, 19, 25, 26, 27, 66, 73, 74 tuppISRHandler-74 tuppMdb-91, 93 tuppMDB-44 tuppModuleClose-6, 46 tuppModuleOpen-6, 29, 46 tuppModuleStart-6, 47, 73 tuppModuleStop-6, 47, 73 tuppPoll-5, 7, 27, 30, 65, 73 tuppRead-7, 53, 54 tuppReadBlock-7, 55 tuppReset-6, 52 tuppRTOPForcePDIVHigh-7, 60 tuppRTOPPathSigLabel-7, 61 tuppSetMask-7, 36, 64 tuppTestReg-8, 68 tuppTributaryTraceMsg-7, 63 src tup_api1.c-82, 93, 94 tup_api2.c-82, 93 tup_hw.c-82, 93, 94 tup_isr.c-82, 93, 94 tup_prof.c-82 tup_rtos.c-82, 93, 94 tup_stat.c-82 tup_util.c-82 tuppUpdate-6, 51 tuppVTPPConfigJ1-7, 57 tuppVTPPDiagLOP-7, 59 tuppVTPPForceIDLE-7, 59 tuppVTPPForcePAIS-7, 58 tuppVTPPSquelchH4-7, 57, 58 tuppWrite-7, 54 tuppWriteBlock-7, 55
C
callbacks
cbackTuppIO-8, 69 cbackTuppRTOP-8, 70 cbackTuppRTTB-8, 71 cbackTuppVTPP-8, 70
D
device
deviceHandle-44
driver
inc tup_api.h-83, 93, 94 tup_defs.h-83, 93, 94 tup_err.h-83, 87 tup_fns.h-83 tup_hw.h-83, 86, 87, 93, 94 tup_rtos.h-83, 84, 85, 86, 87, 93, 94 tup_strs.h-83 tup_typs.h-83, 86
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
87
Tupp+622 (PM5363) Driver Manual
E
error
errDevice-41, 45, 50 errModule-41, 44
sysTuppDPRTask-8, 25, 26, 27, 66, 74, 75, 87 sysTuppDPVBufferGet-8, 77, 78, 85 sysTuppDPVBufferRtn-8, 78, 79, 85 sysTuppISRHandler-8, 25, 26, 27, 66, 73, 74, 87 sysTuppISRHandlerInstall-8, 27, 73, 86 sysTuppISRHandlerRemove-8, 73, 74, 86 sysTuppISVBufferGet-8, 78, 85 sysTuppISVBufferRtn-8, 79, 85 sysTuppMemAlloc-8, 76, 84 sysTuppMemCpy-84 sysTuppMemFree-8, 76, 84 sysTuppMemSet-85 sysTuppPreemptDisable-8, 80, 85 sysTuppPreemptEnable-8, 80, 85 sysTuppRead-8, 53, 55, 72, 86, 91, 92 sysTuppTimerSleep-8, 81, 85 sysTuppWrite-8, 54, 55, 72, 86
P
pointers
pblkSize-34 pblock-55, 56 pcnt-68 pddb-41, 45 pdiv-51 pdpv-69, 70, 71, 78, 79, 88 perrDevice-50 pfirstByte-76 pinitData-30, 31, 32, 33, 34 pinitProfs-41 pisv-66, 79 pmask-55, 56, 64, 65 pmatrix-93 pmaxDevs-91, 93 pmdb-29 pmiv-46 ppblk-34 ppblock-33 pperrDevice-50 ppmask-33, 34 ppmatrix-93 pPrevBuf-93 pProfile-48, 49 pProfileNum-48 psize-33
S
structures
sTUP_CBACK-30, 31, 32, 43 sTUP_CFG_CNT-11, 40, 67 sTUP_CFG_IO-35, 42 sTUP_CFG_RTOP-35, 43 sTUP_CFG_RTTB-35, 43 sTUP_CFG_VTPP-35, 42 sTUP_CFG_XXX-34 sTUP_DDB-11, 41, 91, 92 sTUP_DIV-11, 30, 31, 51 sTUP_DPV-11, 44, 69, 70, 71, 77, 78, 88 sTUP_HNDL-44, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68 sTUP_INIT_DATA_COMP-11, 30, 31, 34
psl-61 sTUP_INIT_DATA_FRM-11, 30, 31, 34 pstartReg-33, 34 sTUP_INIT_DATA_NORM-11, 30, 31, 32
poll
pollISR-30, 32, 43
sTUP_INIT_PROF-11, 31, 41, 48 sTUP_ISV-11, 44, 66, 78, 79 sTUP_MASK-11, 36, 43, 44, 64, 65 sTUP_MDB-11, 29, 41 sTUP_MIV-11, 29, 46 sTUP_STAT_CNT-11, 39, 68
porting functions
sysTuppBufferStart-8, 77, 85 sysTuppBufferStop-8, 79, 85
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
88
Tupp+622 (PM5363) Driver Manual
sTUP_STATUS-2, 3, 11, 37, 38, 39, 67 sTUP_STATUS_IO-11, 37 sTUP_STATUS_RTOP-11, 37, 38
sTUP_STATUS_RTTB-11, 37, 39 sTUP_STATUS_VTPP-11, 37, 38 sTUP_USR_CTXT-42, 69, 70, 71, 88
Proprietary and Confidential to PMC-Sierra, Inc., and for its Customers' Internal Use Document ID PMC-1991288 Issue 2
89

▲Up To Search▲

Price & Availability of 1991288

	To Download 1991288 Datasheet File
If you can't view the Datasheet, Please click here to try to view without PDF Reader .