@@ -91,6 +91,7 @@
 from .decompose_lstm_pass import DecomposeLstmPass  # noqa
 from .decompose_masked_fill_pass import DecomposeMaskedFillPass  # noqa
 from .decompose_matmul import DecomposeMatmulPass  # noqa
+from .decompose_max_pool1d_pass import DecomposeMaxPool1dPass  # noqa
 from .decompose_maxpool2d_with_dilation_pass import DecomposeMaxPool2dPass  # noqa
 from .decompose_meandim_pass import DecomposeMeanDimPass  # noqa
 from .decompose_ne_pass import DecomposeNotEqualPass  # noqa
 
@@ -82,6 +82,7 @@
     DecomposeLstmPass,
     DecomposeMaskedFillPass,
     DecomposeMatmulPass,
+    DecomposeMaxPool1dPass,
     DecomposeMaxPool2dPass,
     DecomposeMeanDimPass,
     DecomposeNotEqualPass,
@@ -681,6 +682,7 @@ def _tosa_pipeline(
                 UnsqueezeBeforeRepeatPass(),
                 DecomposeCumsumPass(exported_program),
                 DecomposeAsStridedCopyPass(),
+                DecomposeMaxPool1dPass(),
                 NormalizeMaxPool2dInputRankPass(),
                 DecomposeMaxPool2dPass(),
                 DecomposeLargeStrideMaxPool2dForU55Pass(),
@@ -856,6 +858,7 @@ def transform_for_annotation_pipeline(self, graph_module: GraphModule):
                     DecomposePowTensorTensorPass(self.tosa_spec, tfa_pass=True),
                     DecomposeLinalgVectorNormPass(tfa_pass=True),
                     DecomposeSqrtPass(tfa_pass=True),
+                    DecomposeMaxPool1dPass(tfa_pass=True),
                     DecomposeSoftmaxPass(
                         tfa_pass=True,
                     ),
 
@@ -0,0 +1,106 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+# Copyright 2026 Arm Limited and/or its affiliates.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import List, Optional, Set, Type, Union
+
+import torch
+from executorch.backends.arm._passes.arm_pass import ArmOpTargetedPass
+from executorch.backends.arm._passes.arm_pass_utils import meta_without_qparams
+from executorch.exir.pass_base import ExportPass
+
+
+def _normalize_to_list(
+    value: Optional[Union[int, List[int], tuple]],
+    default: Optional[List[int]] = None,
+) -> List[int]:
+    """Normalize parameter to list: handle None, int, tuple, list."""
+    if value is None:
+        if default is None:
+            raise ValueError("Value cannot be None without a default")
+        return default
+    if isinstance(value, int):
+        return [value]
+    return list(value)
+
+
+class DecomposeMaxPool1dPass(ArmOpTargetedPass):
+    """Decomposes max_pool1d into max_pool2d via unsqueeze_copy/squeeze_copy
+    operations.
+
+    This pass runs in transform_for_annotation (TFA) pipeline before quantization,
+    ensuring proper quantization annotation for the decomposed ops.
+
+    Transformation:
+        max_pool1d(x, kernel, stride, padding, dilation, ceil_mode)
+            → unsqueeze_copy(x, dim=2)           # (N,C,L) → (N,C,1,L)
+            → max_pool2d(..., [1,k], [1,s], [0,p], [1,d], ceil_mode)
+            → squeeze_copy(..., dims=[2])        # (N,C,1,L') → (N,C,L')
+
+    """
+
+    target_ops = (torch.ops.aten.max_pool1d.default,)
+
+    _passes_required_after: Set[Type[ExportPass]] = set()
+
+    def call_operator(self, op, args, kwargs, meta):
+        if op != torch.ops.aten.max_pool1d.default or not self.allowed_to_transform(
+            meta
+        ):
+            return super().call_operator(op, args, kwargs, meta)
+
+        # Extract and normalize arguments
+        x = args[0]
+        kernel_size = _normalize_to_list(args[1])
+        stride = _normalize_to_list(
+            args[2] if len(args) > 2 else None,
+            default=kernel_size,  # stride defaults to kernel_size
+        )
+        padding = _normalize_to_list(args[3] if len(args) > 3 else 0)
+        dilation = _normalize_to_list(args[4] if len(args) > 4 else 1)
+        ceil_mode = args[5] if len(args) > 5 else False
+
+        # Step 1: Unsqueeze input from 3D to 4D at dim=2
+        # (N, C, L) → (N, C, 1, L)
+        unsqueeze_meta = meta_without_qparams(meta)
+        x_4d = super().call_operator(
+            torch.ops.aten.unsqueeze_copy.default,
+            (x, 2),
+            {},
+            unsqueeze_meta,
+            updated=True,
+        )
+
+        # Step 2: Call max_pool2d with 2D parameters
+        # kernel: [k] → [1, k], stride: [s] → [1, s]
+        # padding: [p] → [0, p], dilation: [d] → [1, d]
+        pooled = super().call_operator(
+            torch.ops.aten.max_pool2d.default,
+            (
+                x_4d,
+                [1] + kernel_size,
+                [1] + stride,
+                [0] + padding,
+                [1] + dilation,
+                ceil_mode,
+            ),
+            {},
+            meta,
+            updated=True,
+        )
+
+        # Step 3: Squeeze output back to 3D at dims=[2]
+        # (N, C, 1, L') → (N, C, L')
+        squeeze_meta = meta_without_qparams(meta)
+        output = super().call_operator(
+            torch.ops.aten.squeeze_copy.dims,
+            (pooled, [2]),
+            {},
+            squeeze_meta,
+            updated=True,
+        )
+
+        return output
@@ -575,6 +575,9 @@ def _get_fixed_qparams_qspec(
     torch.ops.aten.squeeze_copy.default,
     torch.ops.aten.squeeze_copy.dim,
     torch.ops.aten.squeeze_.dim,
+    # DecomposeMaxPool1dPass emits squeeze_copy.dims as a view-like intermediate;
+    # include here so it receives SharedQuantizationSpec from its input.
+    torch.ops.aten.squeeze_copy.dims,
     torch.ops.aten.squeeze.dim,
     torch.ops.aten.squeeze.dims,
     torch.ops.aten.unbind.int,
 
@@ -148,9 +148,7 @@ def test_max_pool2d_vgf_no_quant(test_data: Callable):
 
 
 @common.parametrize("test_data", test_data_suite_all)
-@pytest.mark.xfail(reason="MaxPool1D not yet supported", strict=False)
 @common.SkipIfNoModelConverter
-@pytest.mark.xfail(reason="Quantized MaxPool1D not yet supported in VGF", strict=False)
 def test_max_pool2d_vgf_quant_decomposed(test_data: Callable):
     """Test max_pool1d with VGF pipeline (quantized)."""
     test_data, model_params = test_data()
 
@@ -0,0 +1,79 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+# Copyright 2026 Arm Limited and/or its affiliates.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from executorch.backends.arm._passes import ArmPassManager, DecomposeMaxPool1dPass
+from executorch.backends.arm.test import common
+
+
+class _MaxPool1d(torch.nn.Module):
+    def __init__(self, kernel_size: int, stride: int, padding: int = 0) -> None:
+        super().__init__()
+        self.pool = torch.nn.MaxPool1d(kernel_size, stride, padding)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.pool(x)
+
+
+def test_decompose_max_pool1d_to_max_pool2d() -> None:
+    for kernel_size, stride, padding in [(4, 2, 0), (3, 2, 1), (3, 1, 0)]:
+        module = _MaxPool1d(kernel_size, stride, padding).eval()
+        inputs = (torch.randn(1, 8, 32),)
+        exported = torch.export.export(module, inputs, strict=True)
+
+        result = DecomposeMaxPool1dPass()(exported.graph_module)
+        assert result is not None
+        graph_module = result.graph_module
+        graph_module.graph.lint()
+
+        targets = {
+            node.target
+            for node in graph_module.graph.nodes
+            if node.op == "call_function"
+        }
+        assert torch.ops.aten.max_pool1d.default not in targets
+        assert torch.ops.aten.max_pool2d.default in targets
+
+        actual = graph_module(*inputs)
+        if isinstance(actual, tuple):
+            (actual,) = actual
+        torch.testing.assert_close(module(*inputs), actual)
+
+
+def test_pass_skips_graph_with_submodules_but_no_targets() -> None:
+    """Graphs with call_module nodes but no max_pool1d must not retrace.
+
+    ExportPass retracing raises on call_module nodes; the targeted pre-scan must
+    skip such graphs (e.g. stateful LSTM prepare graphs) entirely.
+
+    """
+    graph = torch.fx.Graph()
+    x = graph.placeholder("x")
+    out = graph.call_module("lin", args=(x,))
+    graph.output(out)
+    graph_module = torch.fx.GraphModule({"lin": torch.nn.Linear(8, 8)}, graph)
+
+    result = DecomposeMaxPool1dPass()(graph_module)
+
+    assert result is not None
+    assert not result.modified
+
+
+def test_max_pool1d_decomposed_in_tfa_pipeline() -> None:
+    module = _MaxPool1d(4, 2).eval()
+    inputs = (torch.randn(1, 16, 50),)
+    exported = torch.export.export(module, inputs, strict=True)
+
+    transformed = ArmPassManager(
+        common.get_tosa_compile_spec("TOSA-1.0+INT")
+    ).transform_for_annotation_pipeline(exported.graph_module)
+
+    targets = {
+        node.target for node in transformed.graph.nodes if node.op == "call_function"
+    }
+    assert torch.ops.aten.max_pool1d.default not in targets
+    assert torch.ops.aten.max_pool2d.default in targets