# 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.

**QNN-SWAOU-18: Users shall not rely on IEEE-754 trapping/flag behavior for floating-point operations.**

This covers exception trapping, FP status flags, division-by-zero, overflow, and underflow exceptions, none of which shall be used as a safety mechanism for QNN HTP FP execution. Based on the overall safety analysis of the HTP FP operators, when used to implement a safety critical requirement, it is recommended for the users to implement robust validation and testing, such as boundary analysis, stress testing, or redundancy checks or other mitigation measures to alleviate the risk.

The FP operators can be grouped based on their capability of generating exceptions resulting in overflow or invalid operations. The behavior of these operators is documented below:

**Group 1 – Safe operators: will not generate overflow or invalid numbers**

Users should expect same result as that from the equivalent operations in ML frameworks as shown in [Supported Operations](https://docs.qualcomm.com/doc/80-63442-10/topic/SupportedOps.html#supported-operations).

| Operators | Inputs | Outputs |
| --- | --- | --- |
| Cast | QNN\_DATATYPE\_INT\_32 | QNN\_DATATYPE\_FLOAT\_32 |
| Concat | QNN\_DATATYPE\_FLOAT\_16,<br>QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| Convert | QNN\_DATATYPE\_UFIXED\_POINT\_8 | QNN\_DATATYPE\_FLOAT\_16 |
| Dequantize | QNN\_DATATYPE\_UFIXED\_POINT\_8 | QNN\_DATATYPE\_FLOAT\_32 |
| ElementWiseSelect | QNN\_DATATYPE\_BOOL\_8,<br>QNN\_DATATYPE\_FLOAT\_16,<br>QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| ElementWiseUnary<br>op=14 “Sin” | QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| ElementWiseUnary<br>op=2 “Atan” | QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| ElementWiseUnary<br>op=4 “Cos” | QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| ElementWiseUnary<br>op=8 “Neg” | QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| Gather | QNN\_DATATYPE\_FLOAT\_16,<br>QNN\_DATATYPE\_INT\_32 | QNN\_DATATYPE\_FLOAT\_16 |
| Reshape | QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| ScatterNd | QNN\_DATATYPE\_FLOAT\_16,<br>QNN\_DATATYPE\_UINT\_32,<br>QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| StridedSlice | QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| Transpose | QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |

**Group 2 – Risky operators: have possibilities to generate unexpected results in HTP**

These operators can generate overflow, saturate or underflow cases. Users should expect HTP to produce unmatched results from the equivalent operators in ML frameworks. For these operators, users are strongly advised to ensure that input parameters are appropriately bounded wherever possible to minimize the risk of unexpected behavior on the HTP.

| Operators | Inputs | Outputs |
| --- | --- | --- |
| Cast | QNN\_DATATYPE\_FLOAT\_32 | QNN\_DATATYPE\_INT\_32 |
| Convert | QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_UFIXED\_POINT\_8 |
| Convert | QNN\_DATATYPE\_FLOAT\_32 | QNN\_DATATYPE\_UFIXED\_POINT\_8 |
| Quantize | QNN\_DATATYPE\_FLOAT\_32 | QNN\_DATATYPE\_UFIXED\_POINT\_8 |
| ElementWiseBinary<br>op=0 “Add” | QNN\_DATATYPE\_FLOAT\_16,<br>QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| ElementWiseBinary<br>op=13 “Mul” | QNN\_DATATYPE\_FLOAT\_16,<br>QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| ElementWiseBinary<br>op=18 “Sub” | QNN\_DATATYPE\_FLOAT\_16,<br>QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| ElementWiseUnary<br>op=15 “sqrt” | QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |

**Group 3 – NaN-introducing operators: possible to generate NaN from valid numbers**

These operators that could trigger NaN, for example: a division by zero, zero multiply with inf, add/sub between inf, sqrt negative value, etc. Users are strongly advised to carefully assess their computations involving these operations, as certain cases may introduce NaN values in lower-precision formats (such as float16) even when equivalent computations in higher precision (such as float32) do not exhibit this behavior. Div and Mul are typically the highest risk primitives for Inf generation. The current behavior and typical model design mitigation is the substitute division with multiplication by the reciprocal.

| Operators | Inputs | Outputs |
| --- | --- | --- |
| ElementWiseBinary<br>op=0 “Add” | QNN\_DATATYPE\_FLOAT\_16,<br>QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| ElementWiseBinary<br>op=2 “Div” | QNN\_DATATYPE\_FLOAT\_16,<br>QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| ElementWiseBinary<br>op=13 “Mul” | QNN\_DATATYPE\_FLOAT\_16,<br>QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| ElementWiseBinary<br>op=18 “Sub” | QNN\_DATATYPE\_FLOAT\_16,<br>QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |
| ElementWiseUnary<br>op=15 “sqrt” | QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_FLOAT\_16 |

**Group 4 – Comparison operators: results get affected when there is NaN**

Due to the non-IEEE representation of FP numbers, the comparison operands might generate an incorrect output. A comparison with a NaN would not return an always false response. NaN could be considered a big value, and the comparison result could be undefined. If these comparisons influence safety-related decision logic, redundant decision checks or sanity constraints should be applied.

| Operators | Inputs | Outputs |
| --- | --- | --- |
| ElementWiseBinary<br>op=6 “Greater” | QNN\_DATATYPE\_FLOAT\_16,<br>QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_BOOL\_8 |
| ElementWiseBinary<br>op=8 “Less” | QNN\_DATATYPE\_FLOAT\_16,<br>QNN\_DATATYPE\_FLOAT\_16 | QNN\_DATATYPE\_BOOL\_8 |

## Tools

### Supported Host Operating Systems

| Supported Host OS |
| --- |
| Linux Ubuntu 22.04 |
| Linux Ubuntu 24.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

| Parameter | Supported Values / Limitations |
| --- | --- |
| backend | “libQnnHtp.so” |
| binary\_file | Name of the binary file to save the<br>context binary |
| model | Valid path to QNN model .so file |
| dlc\_path | Paths to a comma separated list of Deep<br>Learning Containers (DLC)<br><br><br>from which to load the models.<br><br><br>This mandates libQnnModelDlc.so<br>as the –model argument |
| backend\_binary | Name of the binary file to save a<br>backend-specific context binary |
| config\_file | Valid path to configuration file |
| input\_output\_tensor\_mem\_type | [“raw”, “memhandle”] |
| log\_level | “error” |
| op\_packages | Comma separated list of op package and<br>interface provider pairs, specified as:<br><br><br>op\_package\_path:interface\_provider,… |
| output\_dir | Valid directory path |
| set\_output\_tensors | Common separated list of graph name and<br>intermediate tensor names, written as:<br><br><br>graph\_name:tensor\_name,… |

**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\_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: Aug 06, 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)