@@ -14,6 +14,7 @@
     PER_CHANNEL_GROUP_ENCODING,
 )
 from executorch.backends.qualcomm.builders.qnn_constants import OpContextLoader
+from executorch.backends.qualcomm.builders.utils import is_parameter
 from executorch.backends.qualcomm.qnn_preprocess import QnnBackend
 from executorch.backends.qualcomm.serialization.qc_schema import (
     HtpArch,
@@ -41,6 +42,7 @@
     PartitionResult,
 )
 from executorch.exir.backend.utils import tag_constant_data, tag_mutated_buffer
+from executorch.exir.dialects._ops import ops as exir_ops
 from torch.export.exported_program import ExportedProgram
 from torch.fx.passes.infra.partitioner import Partition
 from torch.fx.passes.operator_support import OperatorSupportBase
@@ -61,6 +63,13 @@
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
 
+# dequantize ops with a CPU out variant; others cannot fall back
+CPU_DQ_OPS = {
+    exir_ops.edge.quantized_decomposed.dequantize_per_tensor.default,
+    exir_ops.edge.quantized_decomposed.dequantize_per_tensor.tensor,
+    exir_ops.edge.quantized_decomposed.dequantize_per_channel.default,
+}
+
 
 class QnnOperatorSupport(OperatorSupportBase):
     def __init__(
@@ -240,10 +249,42 @@ def generate_partitions(
             self.skip_node_id_set,
             self.skip_node_op_set,
         )
-        return generate_partitions_from_list_of_nodes(
+        partitions = generate_partitions_from_list_of_nodes(
             edge_program.graph_module,
             op_support=self.op_support_checker,
         )
+        return self._drop_orphaned_parameter_dequants(partitions, edge_program)
+
+    @staticmethod
+    def _drop_orphaned_parameter_dequants(
+        partitions: List[Partition], edge_program: torch.export.ExportedProgram
+    ) -> List[Partition]:
+        """
+        A parameter dequantize whose consumer is not delegated stays on CPU. A QNN
+        Dequantize alone rejects per-channel encodings.
+        """
+        for partition in partitions:
+            stack = [
+                node
+                for node in partition.nodes
+                if node.target in CPU_DQ_OPS
+                and node.meta.get(QCOM_BYPASS_NODE, False)
+                and is_parameter(node.args[0], edge_program)
+            ]
+            while stack:
+                node = stack.pop()
+                if node not in partition.nodes or any(
+                    user in partition.nodes for user in node.users
+                ):
+                    continue
+                partition.remove_node(node)
+                stack.extend(
+                    arg
+                    for arg in node.args
+                    if isinstance(arg, torch.fx.Node)
+                    and arg.meta.get(QCOM_BYPASS_NODE, False)
+                )
+        return [partition for partition in partitions if partition.nodes]
 
     def tag_nodes(
         self, partitions: List[Partition], edge_program: torch.export.ExportedProgram
 
@@ -783,6 +783,83 @@ def forward(self, x):
             if "QNN" in str(e) or "qnn" in str(e):
                 self.skipTest(f"QNN SDK not available: {e}")
 
+    def _assert_cpu_conv_keeps_its_weight_dequantize(
+        self, quant_dtype, use_fp16, skip_node_id_set=None, emit=True
+    ):
+        """A quantized conv kept off QNN must take its per-channel weight dequantize
+        with it. FoldQDQ force-passes that dequantize, so it used to be lowered alone
+        as a QNN Dequantize, which rejects per-channel encodings and fails context
+        binary generation (#19908)."""
+
+        class ConvDepthwiseConv(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.pw1 = torch.nn.Conv2d(8, 16, 1)
+                self.dw = torch.nn.Conv2d(16, 16, 3, padding=1, groups=16)
+                self.pw2 = torch.nn.Conv2d(16, 8, 1)
+
+            def forward(self, x):
+                return self.pw2(torch.relu(self.dw(torch.relu(self.pw1(x)))))
+
+        sample_input = (torch.randn(1, 8, 16, 16),)
+        quantizer = QnnQuantizer()
+        quantizer.set_default_quant_config(
+            quant_dtype=quant_dtype, is_conv_per_channel=True
+        )
+        prepared = prepare_pt2e(
+            torch.export.export(ConvDepthwiseConv().eval(), sample_input).module(),
+            quantizer,
+        )
+        prepared(*sample_input)
+        compiler_specs = generate_qnn_executorch_compiler_spec(
+            soc_model=QcomChipset.SM8650,
+            backend_options=generate_htp_compiler_spec(use_fp16=use_fp16),
+        )
+        try:
+            edge = to_edge_transform_and_lower_to_qnn(
+                convert_pt2e(prepared),
+                sample_input,
+                compiler_specs,
+                skip_node_id_set=skip_node_id_set,
+            )
+        except RuntimeError as e:
+            if "QNN" in str(e) or "qnn" in str(e):
+                self.skipTest(f"QNN SDK not available: {e}")
+            raise
+
+        # inspected before to_executorch(), which swaps in out-variant ops
+        def cpu_nodes(target):
+            return [
+                node
+                for node in edge.exported_program().graph.nodes
+                if node.op == "call_function" and node.target == target
+            ]
+
+        convs = cpu_nodes(exir_ops.edge.aten.convolution.default)
+        self.assertEqual([conv.name for conv in convs], ["aten_convolution_default_1"])
+        dequants = cpu_nodes(
+            exir_ops.edge.quantized_decomposed.dequantize_per_channel.default
+        )
+        self.assertTrue(dequants)
+        for dequant in dequants:
+            self.assertEqual(list(dequant.users), convs)
+        if emit:
+            edge.to_executorch()
+
+    def test_skipped_conv_keeps_its_weight_dequantize_on_cpu(self):
+        self._assert_cpu_conv_keeps_its_weight_dequantize(
+            QuantDtype.use_16a8w,
+            use_fp16=False,
+            skip_node_id_set={"aten_convolution_default_1"},
+        )
+
+    def test_rejected_conv_keeps_its_weight_dequantize_on_cpu(self):
+        # the HTP rejects fp16-activation/int8-weight depthwise conv. Not emitted:
+        # InsertCastForFpActQuantizedWeight casts the CPU conv's bias meta to fp16.
+        self._assert_cpu_conv_keeps_its_weight_dequantize(
+            QuantDtype.use_fp16a8w, use_fp16=True, emit=False
+        )
+
     def test_lowering_accepts_exported_program_without_reexport(self):
         """to_edge_transform_and_lower_to_qnn must lower a caller-supplied
         ExportedProgram as captured, never re-exporting it.