# Functional Safety

This page provides an overview the Qualcomm® AI Engine Direct SDK usage for functional safety use cases.

This document lists all supported QNN backends, APIs, tools, and operations. Where applicable, all supported parameters and limitations are also listed here.
SDK components not listed in this document are unsupported for functional safety use cases.

## ASIL

| Components | ASIL (or equivalent) | Supported Platforms |
| --- | --- | --- |
| SDK - HTP BE runtime<br>(Target Device) | ASIL-B | SA8295 (V68) |
| SDK - HTP BE runtime<br>(Target Device) | ASIL-B | SA8540 (V68) |
| SDK - HTP BE runtime<br>(Target Device) | ASIL-B | SA8650 (V73) |
| SDK - HTP BE runtime<br>(Target Device) | ASIL-B | SA8620 (V75) |
| SDK - HTP BE runtime<br>(Target Device) | ASIL-B | SA8775 (V73) |
| SDK - HTP BE runtime<br>(Target Device) | ASIL-B | SA7775 (V75) |
| SDK - Tools (Host Machine) | TCL2 | N/A |
|  |  |  |
|  |  |  |
|  |  |  |
|  |  |  |
|  |  |  |

Note: For supported tools host platform, refer to Supported Host Operating Systems section below.

## Assumptions of Use

SWAOU: Software Assumption of Use.

**QNN-SWAOU-1: All QNN libraries and artifacts must be obtained from a single SDK version.**

SDK libraries are not backwards compatible with older SDK versions.

**QNN-SWAOU-2: QNN Graph Contexts shall be created and prepared off-target.**

All QNN graph contexts associated with safety critical use cases and targeting the HTP backend shall be created and prepared off-target. On-target graph preparation is not supported.

**QNN-SWAOU-3: QNN Graph Contexts shall be re-generated to match the QNN release running on target.**

Graph contexts must be regenerated to the match SDK version running on the device, even if there are no changes to the network definition. Graph contexts are also not transferable between device model types and must be regenerated.

**QNN-SWAOU-4: Graphs prepared offline shall be verified by the client.**

The Qualcomm AI Engine Direct SDK client, associated tools, and runtime are required to perform final verification of the network models on their platforms. Verification must include performance and accuracy KPI checks.

**QNN-SWAOU-5: Users must validate inference results and delays in getting those results.**

The inference inputs and outputs of any network must be verified by the user. The effect of delays in obtaining inference results must also be evaluated by the user.

**QNN-SWAOU-6: Users shall transfer context binaries generated off-target onto the device.**

Developers use tools listed in the [Supported Tools Summary](https://docs.qualcomm.com/doc/80-63442-10/topic/functional_safety.html#supported-tools-summary) table to generate off-target context binaries (representations of their model). Once a developer is satisfied with their model conversion and context binary generation, they are responsible for transferring the context binary onto the device to the location of their choosing.

**QNN-SWAOU-7: Only unsigned Process Domain (PD) shall be used.**

QNN libraries are unsigned by default. Running on Signed PD is not supported.

**QNN-SWAOU-8: Custom Op Package implementations shall be certified for Functional Safety by the supplier.**

The Qualcomm AI Engine Direct SDK does not guarantee functional safety compliance for user implementations in custom operations.

**QNN-SWAOU-9: Custom Op Package libraries shall be verified for integrity when loaded.**

The user is responsible for [adding a CRC to any Custom Op Package libraries](https://docs.qualcomm.com/doc/80-63442-10/topic/op_package_gen_example.html#htp-custom-op-crc) by using the Software Image Integrity Verification (SWIV) tool.

**QNN-SWAOU-10: Only Functional Safety compliant QNN APIs shall be used.**

Only safe QNN APIs and their supported parameters shall be used, as detailed in this document.

**QNN-SWAOU-11: APIs shall be called in the correct sequence according to the SDK documentation.**

QNN APIs must be called in the correct order. Refer to [Functionally Safe QNN Execution Call Flow](https://docs.qualcomm.com/doc/80-63442-10/topic/functional_safety.html#fusa-qnn-execution-call-flow).

**QNN-SWAOU-12: Only Functional Safety compliant QNN operators shall be used.**

Only supported QNN operators with any applicable restrictions shall be used, as detailed in this document.

**QNN-SWAOU-13: Preemption shall not be expected for HMX and vTCM in SDK versions prior to QNN 2.26.**

(Applicable to SDK versions prior to QNN 2.26. For QNN 2.26 and newer refer to QNN-SWAOU-15.) Preemption is not supported for any operations using HMX/vTCM. Only one operation shall execute at a time within the NSP.

**QNN-SWAOU-14: Applications shall have deadline monitoring.**

For all QNN API calls, applications shall have deadline monitoring as per the System Safety Concept.

**QNN-SWAOU-15: Each application shall only use a single QNN priority for all graphs.**

(Applicable to QNN 2.26 and newer SDK versions for V73 and newer architectures.) Only the deterministic preemption NSP scheduling mechanism is supported. User shall not mix QNN graph priorities within the same application (process).

**QNN-SWAOU-16: An application shall not utilize QnnGraph\_execute and QnnGraph\_executeAsync APIs concurrently with the same graphHandle.**

The unique Qnn\_GraphHandle\_t graphHandle returned from QnnGraph\_retrieve for a single graphName shall not be used to invoke QnnGraph\_execute and QnnGraph\_executeAsync APIs concurrently within the same application (process).

**QNN-SWAOU-17: Users are responsible for ensuring Freedom from Interference (FFI) in concurrent mixed backend criticality use cases.**

If users’ applications utilize mixed backends concurrently, such as a GPU with shared memory, they must ensure the non-safe backend does not interfere with the safe HTP operations.

## Tools

### Supported Host Operating Systems

| Supported Host OS |
| --- |
| Linux Ubuntu 22.04 |

### Supported Tools Summary

| Category | Tool |
| --- | --- |
| Model Conversion | qnn-tensorflow-converter |
| Model Conversion | qnn-tflite-converter |
| Model Conversion | qnn-pytorch-converter |
| Model Conversion | qnn-onnx-converter |
| Model Conversion | qairt-converter |
| Model Preparation | qairt-quantizer |
| Model Preparation | qnn-model-lib-generator |
| Model Preparation | qnn-context-binary-generator |
| Model Preparation | qnn-op-package-generator |
|  |  |
|  |  |
|  |  |
|  |  |

### Detailed Tools Parameters

#### qnn-tensorflow-converter

| Parameter | Supported Values / Limitations |
| --- | --- |
| input\_network | Valid path to the tensorflow model |
| out\_node | Name of output tensor |
| input\_dtype | “float32” |
| input\_layout | [“NCDHW”, “NDHWC”, “NCHW”, “NHWC”, “NFC”, “NCF”,<br><br><br><br>> <br>> <br>> “NTF”, “TNF”, “NF”, “NC”, “F”, “NONTRIVIAL”] |
| input\_dim | &lt;name&gt; &lt;comma separated ints&gt; e.g. “data” “1,256,256,3” |
| output\_path | Valid path for output file |
| float\_bw | [16, 32] |
| quantization\_overrides | Valid path to parameters JSON file |
| input\_list | Valid path to input data file |
| param\_quantizer | [“tf” (default), “enhanced”, “symmetric”] |
| act\_quantizer | [“tf” (default), “enhanced”, “symmetric”] |
| algorithms | Valid algorithm name e.g. “cle” |
| bias\_bw | [8, 32] |
| act\_bw | [8, 16] |
| weight\_bw | 8 |
| float\_bias\_bw | [16, 32] |
| use\_per\_channel\_quantization | N/A (include –use\_per\_channel\_quantization to enable) |
| use\_native\_input\_files | N/A (include –use\_native\_input\_files to enable) |
| use\_native\_output\_files | N/A (include –use\_native\_output\_files to enable) |
| op\_package\_lib | Valid path to op package .so file |
| op\_package\_config | Valid path to QNN op package config XML |

#### qnn-tflite-converter

| Parameter | Supported Values / Limitations |
| --- | --- |
| input\_network | Valid path to the tensorflow model |
| out\_node | Name of output tensor |
| input\_dtype | “float32” |
| input\_layout | [“NCDHW”, “NDHWC”, “NCHW”, “NHWC”, “NFC”, “NCF”,<br><br><br><br>> <br>> <br>> “NTF”, “TNF”, “NF”, “NC”, “F”, “NONTRIVIAL”] |
| input\_dim | &lt;name&gt; &lt;comma separated ints&gt; e.g. “data” “1,256,256,3” |
| output\_path | Valid path for output file |
| float\_bw | [16, 32] |
| input\_list | Valid path to input data file |
| param\_quantizer | [“tf” (default), “enhanced”, “symmetric”] |
| act\_quantizer | [“tf” (default), “enhanced”, “symmetric”] |
| bias\_bw | [8, 32] |
| act\_bw | [8, 16] |
| weight\_bw | 8 |
| float\_bias\_bw | [16, 32] |
| use\_per\_channel\_quantization | N/A (include –use\_per\_channel\_quantization to enable) |
| use\_native\_input\_files | N/A (include –use\_native\_input\_files to enable) |
| use\_native\_output\_files | N/A (include –use\_native\_output\_files to enable) |

#### qnn-pytorch-converter

| Parameter | Supported Values / Limitations |
| --- | --- |
| input\_network | Valid path to the tensorflow model |
| out\_node | Name of output tensor |
| input\_dtype | “float32” |
| input\_layout | [“NCDHW”, “NDHWC”, “NCHW”, “NHWC”, “NFC”, “NCF”,<br><br><br><br>> <br>> <br>> “NTF”, “TNF”, “NF”, “NC”, “F”, “NONTRIVIAL”] |
| input\_dim | &lt;name&gt; &lt;comma separated ints&gt; e.g. “data” “1,256,256,3” |
| output\_path | Valid path for output file |
| float\_bw | [16, 32] |
| input\_list | Valid path to input data file |
| param\_quantizer | [“tf” (default), “enhanced”, “symmetric”] |
| act\_quantizer | [“tf” (default), “enhanced”, “symmetric”] |
| bias\_bw | [8, 32] |
| act\_bw | [8, 16] |
| weight\_bw | 8 |
| float\_bias\_bw | [16, 32] |
| use\_per\_channel\_quantization | N/A (include –use\_per\_channel\_quantization to enable) |
| use\_native\_input\_files | N/A (include –use\_native\_input\_files to enable) |
| use\_native\_output\_files | N/A (include –use\_native\_output\_files to enable) |

#### qnn-onnx-converter

| Parameter | Supported Values / Limitations |
| --- | --- |
| input\_network | Valid path to the ONNX model |
| out\_node | Name of output tensor |
| input\_dtype | “float32” |
| input\_layout | [“NCDHW”, “NDHWC”, “NCHW”, “NHWC”, “NFC”, “NCF”,<br><br><br><br>> <br>> <br>> “NTF”, “TNF”, “NF”, “NC”, “F”, “NONTRIVIAL”] |
| custom\_io | Valid path to custom IO YAML file |
| preserve\_io | &lt;”layout” or “datatype”&gt; &lt;space separated names&gt; |
| input\_dim | &lt;name&gt; &lt;comma separated ints&gt; e.g. “data” “1,256,256,3” |
| no\_simplification | N/A (include –no\_simplification to enable) |
| batch | &lt;int&gt; |
| output\_path | Valid path for output file |
| float\_bw | [16, 32, bf16] |
| quantization\_overrides | Valid path to parameters JSON file |
| input\_list | Valid path to input data file |
| param\_quantizer | [“tf” (default), “enhanced”, “symmetric”] |
| act\_quantizer | [“tf” (default), “enhanced”, “symmetric”] |
| algorithms | Valid algorithm name e.g. “cle” |
| bias\_bw | [8, 32] |
| act\_bw | [8, 16] |
| weight\_bw | 8 |
| float\_bias\_bw | [16, 32] |
| use\_per\_channel\_quantization | N/A (include –use\_per\_channel\_quantization to enable) |
| use\_native\_input\_files | N/A (include –use\_native\_input\_files to enable) |
| use\_native\_output\_files | N/A (include –use\_native\_output\_files to enable) |
| op\_package\_lib | Valid path to op package .so file |
| converter\_op\_package\_lib | Valid path to convert op package .so file |
| op\_package\_config | Valid path to QNN op package config XML |

#### qairt-converter

| Parameter | Supported Values / Limitations |
| --- | --- |
| input\_network | Path to the source framework model |
| out\_tensor\_node | Name of output tensor |
| source\_model\_input\_shape | &lt;name&gt; &lt;comma separated ints&gt; eg. “data” “1,256,256,3” |
| source\_model\_input\_datatype | Names and datatype of input layers specified in format<br><br><br><br>> <br>> <br>> [input\_name datatype] for example: data1 float32 |
| source\_model\_input\_layout | Layout of each input tensor. eg. “data1” NCHW<br><br><br>[“NCDHW”, “NDHWC”, “NCHW”, “NHWC”, “HWIO”, “OIHW”<br><br><br><br>> <br>> <br>> “NFC”, “NCF”, “NTF”, “TNF”, “NF”, “NC”, “F”] |
| preserve\_io\_datatype | &lt;space separated list of inputs and outputs of the graph&gt; |
| output\_path | Valid path for output file |
| float\_bitwidth | [16, 32]  default ‘32’ |
| float\_bias\_bitwidth | [16, 32]  default ‘0’ |
| export\_format | [“DLC\_DEFAULT” (default), “DLC\_STRIP\_QUANT”] |
| op\_package\_config | Valid path to QNN op package config XML |
| quantization\_overrides | Valid path to parameters JSON file |
| onnx\_skip\_simplification | N/A (include –onnx\_skip\_simplification to enable) |

#### qairt-quantizer

| Parameter | Supported Values / Limitations |
| --- | --- |
| input\_dlc | Path to the dlc container containing the model |
| output\_dlc | Valid path for output dlc |
| input\_list | Valid path to input data file |
| bias\_bitwidth | [8, 32]  default ‘8’ |
| act\_bitwidth | [8, 16]  default ‘16’ |
| weights\_bitwidth | [4, 8, 16]  default ‘8’ |
| use\_per\_channel\_quantization | N/A (include –use\_per\_channel\_quantization to enable) |
| preserve\_io\_datatype | &lt;space separated list of inputs and outputs of the graph&gt; |
| use\_native\_input\_files | N/A (include –use\_native\_input\_files to enable) |

#### qnn-model-lib-generator

| Description | Flag | Supported Values / Limitations | Supported Values / Limitations |
| --- | --- | --- | --- |
| QNN Model Source | -c | Valid file path to model .cpp | Valid file path to model .cpp |
| QNN Model Binary | -b | Valid file path to model .bin (if required) | Valid file path to model .bin (if required) |
| Build Target | -t | “x86\_64-linux-clang” | “x86\_64-linux-clang” |
| Output Directory | -o | Valid directory path | Valid directory path |
| Library Name | -l | Valid .so filename (Optional) | Valid .so filename (Optional) |

#### qnn-context-binary-generator

**Supported Config JSON Schema Parameters**

**config\_file**: The config file path is passed to **qnn-context-binary-generator** via the parameter **–config\_file**.

| Section | Parameter | Supported Values / Limitations |
| --- | --- | --- |
| context\_configs | context\_priority | [“low”, “normal”, “normal\_high”, “high”] |
| backend\_extensions | shared\_library\_path | Valid file path |
| backend\_extensions | config\_file\_path | Valid path to backend configuration file |
| backend\_extensions | per\_soc\_config\_file\_path | Array of valid backend configuration file<br>paths for multi-SOC scenarios |
|  |  |  |
|  |  |  |

**backend\_config**: The backend config file path is specified in the main config file above, in the **backend\_extensions** section using the **config\_file\_path** key.

| Section | Parameter | Supported Values / Limitations |
| --- | --- | --- |
| graphs | dlbc | [0, 1] |
| graphs | fp16\_relaxed\_precision | [0, 1] |
| graphs | graph\_names | Array of graph names (corresponding to QnnGraph\_create) |
| graphs | hvx\_threads | &lt;int&gt; |
| graphs | O | [2, 3] |
| graphs | finalize\_config | **P** : [0, 1, 2, 3, 4, 5, 6, 8, 13, 15, 16, 17, 19, 20,<br>21, 22, 23]<br><br><br>**P Point is only supported when O=3 and dsp\_arch is**<br>**v73.** |
| graphs | vtcm\_mb | 8 |
| devices | dsp\_arch | [“v68”, “v73”, “v75”] |
| devices | pd\_session | “unsigned” |
| devices | soc\_id | 39 for SA8295<br><br><br>52 for SA8650 and SA8775<br><br><br>62 for SA8540<br><br><br>67 for SA8620<br><br><br>91 for SA7775 |
|  |  |  |
|  |  |  |
|  |  |  |
|  |  |  |
|  |  |  |
|  |  |  |

#### qnn-op-package-generator

| Parameter | Flag | Supported Values / Limitations | Supported Values / Limitations |
| --- | --- | --- | --- |
| config\_path | -p | Valid file path to op package config | Valid file path to op package config |
| output\_path | -o | Valid directory path | Valid directory path |
| force-generation | -f | N/A (include -f to enable) | N/A (include -f to enable) |

## Supported Runtime APIs and Backends

### Supported Backends

Only the HTP Backend is supported for functional safety. All other backends are unsupported.

| Backend | Architecture | Operating System |
| --- | --- | --- |
| HTP | V68 | QNX |
| HTP | V73 | QNX |
| HTP | V75 | QNX |

### Supported Backend Libraries

For V73, the HTP native backend library libQnnHtpV73Skel.so can be loaded via the corresponding libQnnHtpV73Stub.so on the device’s CPU side to execute graphs on the HTP accelerator via RPC channel.
Alternatively, the libQnnHtpV73.so library supports direct graph execution on HTP without RPC, a mode referred to as Non-RPC execution.

| Architecture | Target Platform | Library |
| --- | --- | --- |
| SA8295 (V68) | ARM: aarch64-qhs225 | libQnnHtp.so |
| SA8295 (V68) | ARM: aarch64-qhs225 | libQnnSystem.so |
| SA8295 (V68) | ARM: aarch64-qhs225 | libQnnHtpV68Stub.so |
| SA8295 (V68) | NSP: hexagon-v68 | libQnnHtpV68Skel.so |
| SA8295 (V68) | NSP: hexagon-v68 | libQnnSystem.so |
| SA8540 (V68) | ARM: aarch64-qos226 | libQnnHtp.so |
| SA8540 (V68) | ARM: aarch64-qos226 | libQnnSystem.so |
| SA8540 (V68) | ARM: aarch64-qos226 | libQnnHtpV68Stub.so |
| SA8540 (V68) | NSP: hexagon-v68 | libQnnHtpV68Skel.so |
| SA8540 (V68) | NSP: hexagon-v68 | libQnnSystem.so |
| SA8650 (V73) | ARM: aarch64-qos227 | libQnnHtp.so |
| SA8650 (V73) | ARM: aarch64-qos227 | libQnnSystem.so |
| SA8650 (V73) | ARM: aarch64-qos227 | libQnnHtpV73Stub.so |
| SA8650 (V73) | NSP: hexagon-v73 | libQnnHtpV73Skel.so |
| SA8650 (V73) | NSP: hexagon-v73 | libQnnHtpV73.so |
| SA8650 (V73) | NSP: hexagon-v73 | libQnnSystem.so |
| SA8775 (V73) | ARM: aarch64-qhs227 | libQnnHtp.so |
| SA8775 (V73) | ARM: aarch64-qhs227 | libQnnSystem.so |
| SA8775 (V73) | ARM: aarch64-qhs227 | libQnnHtpV73Stub.so |
| SA8775 (V73) | NSP: hexagon-v73 | libQnnHtpV73Skel.so |
| SA8775 (V73) | NSP: hexagon-v73 | libQnnHtpV73.so |
| SA8775 (V73) | NSP: hexagon-v73 | libQnnSystem.so |
| SA8620 (V75) /<br>SA7775 (V75) | ARM: aarch64-qhs227 | libQnnHtp.so |
| SA8620 (V75) /<br>SA7775 (V75) | ARM: aarch64-qhs227 | libQnnSystem.so |
| SA8620 (V75) /<br>SA7775 (V75) | ARM: aarch64-qhs227 | libQnnHtpV75Stub.so |
| SA8620 (V75) /<br>SA7775 (V75) | NSP: hexagon-v75 | libQnnHtpV75Skel.so |
| SA8620 (V75) /<br>SA7775 (V75) | NSP: hexagon-v75 | libQnnSystem.so |
|  |  |  |
|  |  |  |
|  |  |  |
|  |  |  |
|  |  |  |

### Supported APIs

| Component | API | SA8295 (V68) | SA8540 (V68) / SA8650 (V73) / SA8620 (V75) /<br>SA8775 (V73) / SA7775 (V75) | SA8650 (V73) Non-RPC |
| --- | --- | --- | --- | --- |
| QnnBackend | QnnBackend\_create | Yes | Yes | Yes |
| QnnBackend | QnnBackend\_free | Yes | Yes | Yes |
| QnnBackend | QnnBackend\_getBuildId | Yes | Yes | Yes |
| QnnBackend | QnnBackend\_registerOpPackage | Yes | Yes | Yes |
| QnnDevice | QnnDevice\_create | Yes | Yes | Yes |
| QnnDevice | QnnDevice\_free | Yes | Yes | Yes |
| QnnDevice | QnnDevice\_getPlatformInfo | Yes | Yes | Yes |
| QnnDevice | QnnDevice\_freePlatformInfo | Yes | Yes | Yes |
| QnnContext | QnnContext\_createFromBinary | Yes | Yes | Yes |
| QnnContext | QnnContext\_free | Yes | Yes | Yes |
| QnnGraph | QnnGraph\_execute | Yes | Yes | Yes |
| QnnGraph | QnnGraph\_executeAsync | **No** | Yes | **No** |
| QnnGraph | QnnGraph\_retrieve | Yes | Yes | Yes |
| QnnMem | QnnMem\_register | Yes | Yes | **No** |
| QnnMem | QnnMem\_deRegister | Yes | Yes | **No** |
| QnnSignal | QnnSignal\_create | Yes | Yes | Yes |
| QnnSignal | QnnSignal\_free | Yes | Yes | Yes |
| QnnSignal | QnnSignal\_trigger | Yes | Yes | Yes |
| QnnSystemContext | QnnSystemContext\_create | Yes | Yes | Yes |
| QnnSystemContext | QnnSystemContext\_free | Yes | Yes | Yes |
| QnnSystemContext | QnnSystemContext\_getMetadata | Yes | Yes | Yes |
| QnnSystemContext | QnnSystemContext\_getBinaryInfo | Yes | Yes | Yes |
|  |  |  |  |  |
|  |  |  |  |  |
|  |  |  |  |  |

### Functionally Safe QNN Execution Call Flow

The sequence below represents a sample recommended functionally safe QNN execution call flow.

- QnnBackend\_create
- QnnDevice\_create
- QnnBackend\_registerOpPackage
- QnnSystemContext\_create
- QnnSystemContext\_getMetadata
- QnnSystemContext\_free
- QnnContext\_createFromBinary
- QnnGraph\_retrieve
- QnnGraph\_execute/QnnGraph\_executeAsync
- QnnContext\_free
- QnnDevice\_free
- QnnBackend\_free

## Supported HTP Operations and Limitations

The following sections list supported and restricted operations for functional safety applications using the HTP backend.

See OpDef/MasterOpDef:QNN Operation Definitions for details about each operation.

All constraints listed in OpDef/HtpOpDefSupplement:HTP Backend Op Definition Supplement are still applicable.

### Supported HTP Operations

| Operation |
| --- |
| Argmax |
| Argmin |
| Batchnorm |
| BatchToSpace |
| Cast |
| ChannelShuffle |
| Concat |
| Conv2d |
| Conv3d |
| Convert |
| CreateSparse |
| CumulativeSum |
| DepthToSpace |
| DepthWiseConv2d |
| Dequantize |
| DetectionOutput |
| ElementWiseAbs |
| ElementWiseAdd |
| ElementWiseAnd |
| ElementWiseAsin |
| ElementWiseAtan |
| ElementWiseBinary |
| ElementWiseCeil |
| ElementWiseCos |
| ElementWiseDivide |
| ElementWiseEqual |
| ElementWiseExp |
| ElementWiseFloor |
| ElementWiseFloorDiv |
| ElementWiseGreater |
| ElementWiseGreaterEqual |
| ElementWiseLess |
| ElementWiseLessEqual |
| ElementWiseLog |
| ElementWiseMaximum |
| ElementWiseMinimum |
| ElementWiseMultiply |
| ElementWiseNeg |
| ElementWiseNeuron |
| ElementWiseNot |
| ElementWiseNotEqual |
| ElementWiseOr |
| ElementWisePower |
| ElementWiseRound |
| ElementWiseRsqrt |
| ElementWiseSelect |
| ElementWiseSign |
| ElementWiseSin |
| ElementWiseSquaredDifference |
| ElementWiseSquareRoot |
| ElementWiseSubtract |
| ElementWiseUnary |
| ElementWiseXor |
| Elu |
| ExpandDims |
| ExtractGlimpse |
| ExtractPatches |
| FullyConnected |
| Gather |
| GatherElements |
| GatherNd |
| Gelu |
| GetSparseIndices |
| GetSparseValues |
| GridSample |
| GroupNorm |
| HardSwish |
| InstanceNorm |
| L2Norm |
| LayerNorm |
| LogSoftmax |
| Lrn |
| MatMul |
| MultiClassNms |
| NonMaxSuppression |
| NonZero |
| OneHot |
| Pack |
| Pad |
| PoolAvg2d |
| PoolAvg3d |
| PoolMax2d |
| Prelu |
| Quantize |
| ReduceMax |
| ReduceMean |
| ReduceMin |
| ReduceSum |
| Relu |
| Relu1 |
| Relu6 |
| ReluMinMax |
| Reshape |
| Resize |
| ResizeBilinear |
| ResizeNearestNeighbor |
| RoiAlign |
| ScatterElements |
| ScatterNd |
| Sigmoid |
| Softmax |
| SpaceToBatch |
| SpaceToDepth |
| SparseToDense |
| Split |
| Squeeze |
| StridedSlice |
| Tanh |
| Tile |
| TopK |
| Transpose |
| TransposeConv2d |
| TransposeConv3d |
| UnPack |

### Restricted Operations

| Operation | Additional Constraints and Limitations |
| --- | --- |
| Lstm | **–expand\_lstm\_op\_structure** parameter shall be used<br>during model conversion if the model contains Lstm |

Last Published: Jun 04, 2026

[Previous Topic
LPAI](https://docs.qualcomm.com/bundle/publicresource/80-63442-10/topics/LpaiOpDefSupplement.md) [Next Topic
API](https://docs.qualcomm.com/bundle/publicresource/80-63442-10/topics/general_api.md)

Source: [https://docs.qualcomm.com/doc/80-63442-10/topic/functional_safety.html](https://docs.qualcomm.com/doc/80-63442-10/topic/functional_safety.html)