Merge branch 'master' into toyota-bsm

.github/workflows/test_models.yml

@@ -46,23 +46,6 @@ jobs:
           CHECK_OOB: 0
           GMMU: 0
         run: tools/op.sh test -v openpilot/sunnypilot/modeld_v2/tests/test_convert_upstream_pkl.py
-      - name: Resolve commaai's tinygrad pin, which their precompiled chestnut model is built and converted with
-        id: upstream-tg
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          read -r sha url < <(gh api repos/commaai/openpilot/contents/tinygrad_repo --jq '.sha + " " + .submodule_git_url')
-          echo "commaai/openpilot master pins $url@$sha, ours is $(git rev-parse HEAD:tinygrad_repo)"
-          dir="$RUNNER_TEMP/upstream_tinygrad"
-          git init -q "$dir" && git -C "$dir" fetch -q --depth 1 "$url" "$sha" && git -C "$dir" checkout -q FETCH_HEAD
-          echo "path=$dir" >> "$GITHUB_OUTPUT"
-      - name: Convert a pickled USB+AMD jit under commaai's tinygrad, as the chestnut model build does
-        env:
-          DEV: MOCKUSB+AMD
-          CHECK_OOB: 0
-          GMMU: 0
-          PYTHONPATH: ${{ steps.upstream-tg.outputs.path }}:${{ github.workspace }}
-        run: tools/op.sh test -v openpilot/sunnypilot/modeld_v2/tests/test_convert_upstream_pkl.py
       - name: Where tinygrad moved, for the helper or failure point named above
         if: failure() && github.event_name == 'pull_request'
         run: |

.gitmodules

@@ -4,6 +4,7 @@
 [submodule "opendbc"]
   path = opendbc_repo
   url = https://github.com/sunnypilot/opendbc.git
+  branch = toyotabsmhack
 [submodule "msgq"]
   path = msgq_repo
   url = https://github.com/sunnypilot/msgq.git

openpilot/common/params_keys.h

@@ -245,6 +245,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"SubaruStopAndGoManualParkingBrake", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"TeslaCoopSteering", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"TeslaMadsScreenButton", {PERSISTENT | BACKUP, INT, "0"}},
+    {"ToyotaEnhancedBsm", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"ToyotaEnforceStockLongitudinal", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"ToyotaStopAndGoHack", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"ToyotaTSS2Smooth", {PERSISTENT | BACKUP, BOOL, "0"}},

openpilot/selfdrive/ui/sunnypilot/layouts/settings/vehicle/brands/toyota.py

@@ -12,10 +12,16 @@ from openpilot.system.ui.widgets import DialogResult
 from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
 from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp
 from opendbc.car.toyota.values import ToyotaFlags
+from opendbc.sunnypilot.car.toyota.values import ToyotaFlagsSP
 
 
 ONROAD_ONLY_DESCRIPTION = tr_noop("Start the vehicle to check vehicle compatibility.")
 SNG_HACK_UNAVAILABLE = tr_noop("sunnypilot Longitudinal Control must be available and enabled for your vehicle to use this feature.")
+BSM_UNAVAILABLE = tr_noop("Enhanced Blind Spot Monitoring requires a TSS2 Toyota/Lexus without SecOC, " +
+                           "or a smartDSU with sunnypilot longitudinal control.")
+BSM_STOCK_LONG_UNAVAILABLE = tr_noop("Enhanced Blind Spot Monitoring is not available while Enforce Factory Longitudinal Control is enabled.")
+BSM_REQUIRED = tr_noop("This vehicle does not report blind spot status over the standard CAN signals. " +
+                        "Enhanced Blind Spot Monitoring is required for blind spot detection.")
 PLATFORM_UNAVAILABLE = tr_noop("This feature is currently not available on this platform.")
 
 DESCRIPTIONS = {
@@ -26,6 +32,10 @@ DESCRIPTIONS = {
     'sunnypilot will allow some Toyota/Lexus cars to auto resume during stop and go traffic. ' +
     'This feature is only applicable to certain models that are able to use longitudinal control. This is an alpha feature. Use at your own risk.'
   ),
+  'enhanced_bsm': tr_noop(
+    'sunnypilot will poll the blind spot monitor diagnostics directly from the radar. Use this on vehicles whose blind spot monitors ' +
+    'do not report blind spot status over the standard CAN signals. This is an alpha feature. Use at your own risk.'
+  ),
   'tss2_smooth': tr_noop(
     'Enable smoother longitudinal control for TSS2 vehicles. ' +
     'Uses a custom speed-dependent integral gain curve for smoother traffic driving.'
@@ -53,6 +63,14 @@ class ToyotaSettings(BrandSettings):
       enabled=lambda: not ui_state.engaged,
     )
 
+    self.enhanced_bsm = toggle_item_sp(
+      lambda: tr("Enhanced Blind Spot Monitoring (Alpha)"),
+      description=lambda: tr(DESCRIPTIONS["enhanced_bsm"]),
+      initial_state=ui_state.params.get_bool("ToyotaEnhancedBsm"),
+      callback=self._on_enable_enhanced_bsm,
+      enabled=lambda: not ui_state.engaged,
+    )
+
     self.tss2_smooth = toggle_item_sp(
       lambda: tr("TSS2 Smooth Longitudinal (Alpha)"),
       description=lambda: tr(DESCRIPTIONS["tss2_smooth"]),
@@ -64,6 +82,7 @@ class ToyotaSettings(BrandSettings):
     self.items = [
       self.enforce_stock_longitudinal,
       self.stop_and_go_hack,
+      self.enhanced_bsm,
       self.tss2_smooth,
     ]
 
@@ -130,6 +149,25 @@ class ToyotaSettings(BrandSettings):
       ui_state.params.put_bool("ToyotaStopAndGoHack", False)
       ui_state.params.put_bool("OnroadCycleRequested", True)
 
+  def _on_enable_enhanced_bsm(self, state: bool):
+    if state:
+      def confirm_callback(result: int):
+        if result == DialogResult.CONFIRM:
+          ui_state.params.put_bool("ToyotaEnhancedBsm", True)
+          ui_state.params.put_bool("OnroadCycleRequested", True)
+        else:
+          self.enhanced_bsm.action_item.set_state(False)
+
+      content = (f"<h1>{self.enhanced_bsm.title}</h1><br>" +
+                 f"<p>{self.enhanced_bsm.description}</p>")
+
+      dlg = ConfirmDialog(content, tr("Enable"), rich=True, callback=confirm_callback)
+      gui_app.push_widget(dlg)
+
+    else:
+      ui_state.params.put_bool("ToyotaEnhancedBsm", False)
+      ui_state.params.put_bool("OnroadCycleRequested", True)
+
   def update_settings(self):
     if ui_state.CP is not None:
       longitudinal = ui_state.CP.openpilotLongitudinalControl
@@ -150,6 +188,31 @@ class ToyotaSettings(BrandSettings):
         if show_desc:
           self.stop_and_go_hack.show_description(True)
 
+      # Enhanced BSM needs the radar diagnostic address, which is only in the TX allowlist for
+      # TSS2 cars without SecOC, or for TSS-P cars whose smartDSU lets sunnypilot control
+      # longitudinal. Enforcing factory longitudinal control rules both of those out.
+      sdsu_bsm_supported = (longitudinal and ui_state.CP_SP is not None and
+                            bool(ui_state.CP_SP.flags & ToyotaFlagsSP.SMART_DSU))
+      bsm_supported = (not bool(ui_state.CP.flags & ToyotaFlags.SECOC) and
+                       (bool(ui_state.CP.flags & ToyotaFlags.TSS2) or sdsu_bsm_supported))
+      bsm_available = bsm_supported and not enforce_stock
+      self.enhanced_bsm.action_item.set_enabled(bsm_available and not ui_state.engaged)
+
+      bsm_desc = tr(DESCRIPTIONS["enhanced_bsm"])
+      if not bsm_supported:
+        self.enhanced_bsm.action_item.set_state(False)
+        bsm_desc = "<b>" + tr(BSM_UNAVAILABLE) + "</b>\n\n" + bsm_desc
+      elif enforce_stock:
+        self.enhanced_bsm.action_item.set_state(False)
+        bsm_desc = "<b>" + tr(BSM_STOCK_LONG_UNAVAILABLE) + "</b>\n\n" + bsm_desc
+      elif ui_state.CP_SP is not None and ui_state.CP_SP.flags & ToyotaFlagsSP.SP_NEED_DEBUG_BSM:
+        bsm_desc = "<b>" + tr(BSM_REQUIRED) + "</b>\n\n" + bsm_desc
+
+      if self.enhanced_bsm.description != bsm_desc:
+        self.enhanced_bsm.set_description(bsm_desc)
+        if not bsm_available:
+          self.enhanced_bsm.show_description(True)
+
       tss2 = bool(ui_state.CP.flags & ToyotaFlags.TSS2)
       if longitudinal and not enforce_stock and tss2:
         self.tss2_smooth.action_item.set_enabled(not ui_state.engaged)
@@ -173,6 +236,12 @@ class ToyotaSettings(BrandSettings):
         self.stop_and_go_hack.set_description(new_desc)
         self.stop_and_go_hack.show_description(True)
 
+      self.enhanced_bsm.action_item.set_enabled(False)
+      bsm_desc = "<b>" + tr(ONROAD_ONLY_DESCRIPTION) + "</b>\n\n" + tr(DESCRIPTIONS["enhanced_bsm"])
+      if self.enhanced_bsm.description != bsm_desc:
+        self.enhanced_bsm.set_description(bsm_desc)
+        self.enhanced_bsm.show_description(True)
+
       self.tss2_smooth.action_item.set_enabled(False)
       new_desc = "<b>" + tr(ONROAD_ONLY_DESCRIPTION) + "</b>\n\n" + tr(DESCRIPTIONS["tss2_smooth"])
       if self.tss2_smooth.description != new_desc:

openpilot/sunnypilot/modeld_v2/convert_upstream_pkl.py

@@ -66,75 +66,47 @@ def _patched(buf, topo) -> tuple[bytearray, dict]:
   return blob, rows
 
 
-def _packed_args(program) -> dict[int, int]:
-  from tinygrad.device import TinyELF
-  params = getattr(program.arg, "params", None) or ()
-  return {off: p.arg.slot for (off, _), p in zip(TinyELF.iter_sig(tuple((None, p.addrspace, p.dtype, ()) for p in params)), params, strict=True)}
-
-
-def _outer_slot(u, packed: dict[int, int]) -> int | None:
-  from tinygrad.uop.ops import Ops
-  if u.op is Ops.PARAM:
-    return None if packed else u.arg.slot
-  if u.op.name == "REFPARAM":
-    return u.arg.slot
-  if packed and u.op is Ops.LOAD and u.src[0].op is Ops.INDEX and _root(u.src[0].src[0]).op is Ops.PARAM:
-    index = _evaluate(u.src[0].src[1], {}, packed)
-    return None if index is None else packed.get(index * u.dtype.itemsize)
-  return None
-
-
-def _evaluate(u, env, packed: dict[int, int]):
+def _evaluate(u, env):
   from tinygrad.uop.ops import GroupOp, Ops, exec_alu
   if u.op in (Ops.AFTER, Ops.CAST, Ops.BITCAST):
-    return _evaluate(u.src[0], env, packed)
+    return _evaluate(u.src[0], env)
   if u.op is Ops.CONST:
     return u.arg
-  if u.op is Ops.RANGE:
-    return env.get(u)
-  if (slot := _outer_slot(u, packed)) is not None:
-    return env.get(slot)
+  if u.op in (Ops.PARAM, Ops.RANGE):
+    return env.get(u.arg.slot if u.op is Ops.PARAM else u)
   if u.op is Ops.LOAD:
-    table, index = _root(u.src[0].src[0]), _evaluate(u.src[0].src[1], env, packed)
+    table, index = _root(u.src[0].src[0]), _evaluate(u.src[0].src[1], env)
     return struct.unpack_from(u.dtype.fmt, table.arg, index * u.dtype.itemsize)[0] if table.op is Ops.BINARY and index is not None else None
-  if u.op in GroupOp.ALU and None not in (values := [_evaluate(x, env, packed) for x in u.src]):
+  if u.op in GroupOp.ALU and None not in (values := [_evaluate(x, env) for x in u.src]):
     return exec_alu(u.op, u.dtype, values, *([False] if "truncate_output" in inspect.signature(exec_alu).parameters else []))
   return None
 
 
 def _input_pokes(submit, kernargs) -> dict[int, tuple[int, int]]:
   from tinygrad.uop.ops import Ops
-  outer, packed = dict(enumerate(submit.src[1:])), _packed_args(submit.src[0])
+  outer = dict(enumerate(submit.src[1:]))
   kernargs_params = {i for i, a in outer.items() if a.op is Ops.GETADDR and _root(a.src[0]) is kernargs}
   inputs = {i: _root(a.src[0]).arg.slot for i, a in outer.items() if a.op is Ops.GETADDR and _root(a.src[0]).op is Ops.PARAM}
   pokes = {}
   for call in (u for u in submit.src[0].src[0].toposort() if u.op is Ops.CALL and len(u.src) > 3):
     _, address, value, *_ = call.src[1:]
-    used = list({slot for x in value.toposort() if (slot := _outer_slot(x, packed)) is not None} & inputs.keys())
-    if len(used) != 1 or not kernargs_params & {_outer_slot(x, packed) for x in address.toposort()}:
+    used = list({x.arg.slot for x in value.toposort() if x.op is Ops.PARAM} & inputs.keys())
+    if len(used) != 1 or not kernargs_params & {x.arg.slot for x in address.toposort() if x.op is Ops.PARAM}:
       continue
     ranges = list(dict.fromkeys(x for x in (*address.toposort(), *value.toposort()) if x.op is Ops.RANGE))
     for trip in itertools.product(*[range(int(r.vmax) + 1) for r in ranges]):
       env = dict.fromkeys(outer, 0) | dict(zip(ranges, trip, strict=True))
-      if (offset := _evaluate(address, env, packed)) % 8 == 0:
-        pokes[offset] = (inputs[used[0]], _evaluate(value, env, packed))
+      if (offset := _evaluate(address, env)) % 8 == 0:
+        pokes[offset] = (inputs[used[0]], _evaluate(value, env))
   return pokes
 
 
-def _elf(image: bytes, rodata: int, entry: int) -> bytes:
-  spans = [(".text", 0, rodata), (".rodata", rodata, len(image))] if entry < rodata else \
-          [(".data", 0, rodata), (".rodata", rodata, entry), (".text", entry, len(image))]
-  sections, names = [(0, 0, 0, 0, b"")], b"\0"
-  for name, start, end in (span for span in spans if span[1] < span[2]):
-    sections.append((len(names), 1, 6 if name == ".text" else 2, ALIGNMENT + start, image[start:end]))
-    names += name.encode() + b"\0"
-  sections.append((len(names), 3, 0, 0, names + b".shstrtab\0"))
-  offset, data, headers = 64, b"", []
-  for name, kind, flags, address, content in sections:
-    headers.append(struct.pack("<IIQQQQIIQQ", name, kind, flags, address, offset, len(content), 0, 0, 1, 0))
+def _elf(image: bytes, rodata: int) -> bytes:
+  names, offset, data, headers = b"\0.text\0.rodata\0.shstrtab\0", 64, b"", []
+  for name, kind, address, content in [(0, 0, 0, b""), (1, 1, ALIGNMENT, image[:rodata]), (7, 1, ALIGNMENT + rodata, image[rodata:]), (15, 3, 0, names)]:
+    headers.append(struct.pack("<IIQQQQIIQQ", name, kind, 2 if kind == 1 else 0, address, offset, len(content), 0, 0, 1, 0))
     data, offset = data + content, offset + len(content)
-  header = struct.pack("<HHIQQQIHHHHHH", 1, 0xe0, 1, 0, 0, offset, 0, 64, 0, 0, 64, len(sections), len(sections) - 1)
-  return b"\x7fELF\x02\x01\x01" + bytes(9) + header + data + b"".join(headers)
+  return b"\x7fELF\x02\x01\x01" + bytes(9) + struct.pack("<HHIQQQIHHHHHH", 1, 0xe0, 1, 0, 0, offset, 0, 64, 0, 0, 64, 4, 3) + data + b"".join(headers)
 
 
 def convert(jit, kwargs: dict, frame: dict, target) -> tuple[dict, memoryview]:
@@ -183,7 +155,7 @@ def convert(jit, kwargs: dict, frame: dict, target) -> tuple[dict, memoryview]:
     if image_alloc not in programs:
       image = bytes(_patched(image_alloc, topo)[0])
       rodata = next(r for r in range(0, len(image) - 24, 64) if r + struct.unpack_from("<q", image, r + 16)[0] == entry)
-      programs[image_alloc] = blob.add(_elf(image, rodata, entry))
+      programs[image_alloc] = blob.add(_elf(image, rodata))
     start, size = _view(arguments.src[0])
     args = []
     for slot in range(start, start + unwrap(size), 8):

openpilot/sunnypilot/modeld_v2/helpers.py

@@ -264,8 +264,8 @@ def _program_uop(call: dict, lib: bytes):
     parameter = UOp.param(call["globals"][compact_slot], _dtype(dtype), math.prod(shape))
     image = (shape[0], shape[1]) if len(shape) == 3 and shape[2] == 4 else None
     parameters.append(parameter.replace(arg=_fields(parameter.arg, name=name, image=image)))
-  info = _fields(ProgramInfo, global_size=tuple(call["global_size"]), local_size=tuple(call["local_size"]), params=tuple(parameters),
-                 globals=tuple(call["globals"]), outs=tuple(call["outs"]), ins=tuple(call["ins"]), target=_fields(Target, **call["target"]))
+  info = _fields(ProgramInfo, global_size=tuple(call["global_size"]), local_size=tuple(call["local_size"]), globals=tuple(call["globals"]),
+                 outs=tuple(call["outs"]), ins=tuple(call["ins"]), target=_fields(Target, **call["target"]))
   return UOp(Ops.PROGRAM, src=(UOp(Ops.SINK, arg=KernelInfo(name=call["name"])), UOp(Ops.LINEAR, src=tuple(parameters)),
                                UOp(Ops.SOURCE, arg=""), UOp(Ops.BINARY, arg=lib)), arg=info)
 

openpilot/sunnypilot/modeld_v2/tests/test_convert_upstream_pkl.py

@@ -6,7 +6,6 @@ See the LICENSE.md file in the root directory for more details.
 """
 import os
 import re
-import struct
 import sys
 import tempfile
 import unittest
@@ -26,8 +25,8 @@ if sys.platform == "darwin" and os.environ.get("DEV", "").startswith("MOCKUSB"):
 
 from openpilot.common.test import OpenpilotTestCase
 from openpilot.sunnypilot.modeld_v2 import convert_upstream_pkl
-from openpilot.sunnypilot.modeld_v2.convert_upstream_pkl import _elf, convert
-from openpilot.sunnypilot.modeld_v2.helpers import ALIGNMENT, PlainJit, load_model
+from openpilot.sunnypilot.modeld_v2.convert_upstream_pkl import convert
+from openpilot.sunnypilot.modeld_v2.helpers import PlainJit, load_model
 from openpilot.sunnypilot.modeld_v2.plain_artifact_compiler import capture_frame
 
 IMG, DESIRE, STATE, OUT = (6, 8, 8), (8,), (4, 16), (1, 32)
@@ -120,18 +119,3 @@ class TestConvertUpstreamPkl(OpenpilotTestCase):
     bundle = load_model(out, cache=False, verify=True)
     assert bundle["metadata"] == {"name": "tiny"} and bundle["input_specs"] == self.input_specs and bundle["output_specs"] == self.output_specs
     self.assert_matches_eager(bundle["run"], 6)
-
-
-class TestKernelElf(OpenpilotTestCase):
-  def test_sections_follow_the_code(self):
-    from tinygrad.runtime.support.elf import elf_loader
-    code = bytes(range(1, 129))
-    for rodata, entry in ((len(code), 0), (0, 256)):
-      image = bytearray(code + bytes(64) if entry < rodata else bytes(256) + code)
-      struct.pack_into("<q", image, rodata + 16, entry - rodata)
-      loaded, sections, _ = elf_loader(_elf(bytes(image), rodata, entry))
-      headers = {section.name: section.header for section in sections}
-      assert bytes(loaded[ALIGNMENT:]) == bytes(image), "the uploaded program differs from the pickle's"
-      assert headers[".rodata"].sh_addr == ALIGNMENT + rodata, "the loader reads the kernel descriptor at .rodata"
-      text = headers[".text"]
-      assert text.sh_addr <= ALIGNMENT + entry < text.sh_addr + text.sh_size, "the amd mock sizes the code from the entry to the end of .text"

openpilot/sunnypilot/selfdrive/car/interfaces.py

@@ -126,6 +126,7 @@ def initialize_params(params) -> list[dict[str, Any]]:
   keys.extend([
     "ToyotaEnforceStockLongitudinal",
     "ToyotaStopAndGoHack",
+    "ToyotaEnhancedBsm",
     "ToyotaTSS2Smooth",
   ])
 

openpilot/sunnypilot/sunnylink/capabilities.py

@@ -13,6 +13,7 @@ from opendbc.car.subaru.values import CAR as SUBARU_CAR, SubaruFlags
 from opendbc.car.toyota.values import CAR as TOYOTA_CAR, ToyotaFlags
 from opendbc.sunnypilot.car.interfaces import has_bsm
 from opendbc.sunnypilot.car.tesla.values import TeslaFlagsSP
+from opendbc.sunnypilot.car.toyota.values import ToyotaFlagsSP
 from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
 from openpilot.common.hardware import HARDWARE
@@ -44,6 +45,7 @@ CAPABILITY_FIELDS = (
   "device_type",
   "subaru_has_sng",
   "hyundai_alpha_long_available",
+  "toyota_enhanced_bsm_available",
   "toyota_tss2",
   "custom_model_active",
 )
@@ -68,6 +70,7 @@ CAPABILITY_LABELS: dict[str, str] = {
   "device_type": "Device type",
   "subaru_has_sng": "Subaru Stop-and-Go available",
   "hyundai_alpha_long_available": "Hyundai Alpha Longitudinal available",
+  "toyota_enhanced_bsm_available": "Toyota Enhanced BSM available",
   "toyota_tss2": "Toyota TSS2 platform",
   "custom_model_active": "Non-Default model selected",
 }
@@ -89,6 +92,7 @@ CAR_CAPABILITY_FIELDS = (
   "subaru_has_sng",
   "hyundai_alpha_long_available",
   "toyota_tss2",
+  "toyota_enhanced_bsm_available",
 )
 
 # Explicit defaults for non-boolean capability fields
@@ -104,7 +108,7 @@ def _bundle_field(bundle: dict | None, key: str) -> str:
   return bundle.get(key, "") if isinstance(bundle, dict) else ""
 
 
-def _resolve_brand_capabilities(caps: dict, bundle_platform: str, CP) -> None:
+def _resolve_brand_capabilities(caps: dict, bundle_platform: str, CP, CP_SP=None) -> None:
   """Set brand-specific capabilities from bundle platform or CarParams fallback.
 
   Bundle (manual car selection) is a pre-fingerprint approximation.
@@ -138,11 +142,18 @@ def _resolve_brand_capabilities(caps: dict, bundle_platform: str, CP) -> None:
   elif brand == "toyota":
     if bundle_platform:
       try:
-        caps["toyota_tss2"] = bool(TOYOTA_CAR[bundle_platform].config.flags & ToyotaFlags.TSS2)
+        flags = TOYOTA_CAR[bundle_platform].config.flags
+        caps["toyota_tss2"] = bool(flags & ToyotaFlags.TSS2)
+        caps["toyota_enhanced_bsm_available"] = bool(flags & ToyotaFlags.TSS2) and not bool(flags & ToyotaFlags.SECOC)
       except KeyError:
         cloudlog.exception(f"capabilities: unknown toyota platform {bundle_platform!r}")
     elif CP is not None:
       caps["toyota_tss2"] = bool(CP.flags & ToyotaFlags.TSS2)
+      # same gate as _initialize_toyota: TSS2 without SecOC, or TSS-P with a smartDSU and openpilot
+      # longitudinal control (the bundle path can't see 0x2FF, so it stays TSS2-only)
+      sdsu_bsm = CP_SP is not None and bool(CP_SP.flags & ToyotaFlagsSP.SMART_DSU) and bool(CP.openpilotLongitudinalControl)
+      caps["toyota_enhanced_bsm_available"] = (not bool(CP.flags & ToyotaFlags.SECOC) and
+                                               (bool(CP.flags & ToyotaFlags.TSS2) or sdsu_bsm))
 
 
 def generate_capabilities(params: Params | None = None) -> dict:
@@ -217,7 +228,7 @@ def generate_capabilities(params: Params | None = None) -> dict:
   if CP is not None:
     caps["has_bsm"] = has_bsm(CP, CP_SP)
 
-  _resolve_brand_capabilities(caps, bundle_platform, CP)
+  _resolve_brand_capabilities(caps, bundle_platform, CP, CP_SP)
 
   return caps
 

openpilot/sunnypilot/sunnylink/docs/README.md

@@ -156,7 +156,7 @@ The tables below describe the **compiled** `settings_ui.json` schema — what th
 
 **Enablement rules**: Grayed out (disabled) when rules fail. Frontend shows a contextual badge explaining why.
 
-**Capability fields** (referenced in rules): `has_longitudinal_control`, `has_icbm`, `icbm_available`, `torque_allowed`, `brand`, `pcm_cruise`, `alpha_long_available`, `steer_control_type`, `has_bsm`, `is_release`, `is_sp_release`, `is_development`, `tesla_has_vehicle_bus`, `has_stop_and_go`, `stock_longitudinal`
+**Capability fields** (referenced in rules): `has_longitudinal_control`, `has_icbm`, `icbm_available`, `torque_allowed`, `brand`, `pcm_cruise`, `alpha_long_available`, `steer_control_type`, `has_bsm`, `is_release`, `is_sp_release`, `is_development`, `tesla_has_vehicle_bus`, `has_stop_and_go`, `stock_longitudinal`, `toyota_enhanced_bsm_available`
 
 ---
 

openpilot/sunnypilot/sunnylink/settings_ui.json

@@ -2361,6 +2361,28 @@
             }
           ]
         },
+        {
+          "key": "ToyotaEnhancedBsm",
+          "widget": "toggle",
+          "needs_onroad_cycle": true,
+          "title": "Enhanced Blind Spot Monitoring (Alpha)",
+          "description": "sunnypilot will poll the blind spot monitor diagnostics directly from the radar. Use this on vehicles whose blind spot monitors do not report blind spot status over the standard CAN signals. This is an alpha feature. Use at your own risk.",
+          "enablement": [
+            {
+              "type": "not_engaged"
+            },
+            {
+              "type": "capability",
+              "field": "toyota_enhanced_bsm_available",
+              "equals": true
+            },
+            {
+              "type": "capability",
+              "field": "stock_longitudinal",
+              "equals": false
+            }
+          ]
+        },
         {
           "key": "ToyotaTSS2Smooth",
           "widget": "toggle",

openpilot/sunnypilot/sunnylink/settings_ui_src/pages/vehicle.yaml

@@ -101,6 +101,21 @@ sections:
     - type: param
       key: ToyotaEnforceStockLongitudinal
       equals: false
+  - key: ToyotaEnhancedBsm
+    widget: toggle
+    needs_onroad_cycle: true
+    title: Enhanced Blind Spot Monitoring (Alpha)
+    description: sunnypilot will poll the blind spot monitor diagnostics directly from the radar. Use this on vehicles whose
+      blind spot monitors do not report blind spot status over the standard CAN signals. This is an alpha feature. Use at
+      your own risk.
+    enablement:
+    - $ref: '#/macros/not_engaged'
+    - type: capability
+      field: toyota_enhanced_bsm_available
+      equals: true
+    - type: capability
+      field: stock_longitudinal
+      equals: false
   - key: ToyotaTSS2Smooth
     widget: toggle
     needs_onroad_cycle: true

openpilot/sunnypilot/sunnylink/tests/test_capabilities.py

@@ -70,12 +70,18 @@ class TestOpaquePerBrandFlags(OpenpilotTestCase):
   def test_hyundai_alpha_long_available_field_present(self):
     assert "hyundai_alpha_long_available" in CAPABILITY_FIELDS
 
+  def test_toyota_enhanced_bsm_available_field_present(self):
+    assert "toyota_enhanced_bsm_available" in CAPABILITY_FIELDS
+
   def test_subaru_has_sng_default_false(self, caps):
     assert caps["subaru_has_sng"] is False
 
   def test_hyundai_alpha_long_available_default_false(self, caps):
     assert caps["hyundai_alpha_long_available"] is False
 
+  def test_toyota_enhanced_bsm_available_default_false(self, caps):
+    assert caps["toyota_enhanced_bsm_available"] is False
+
   def test_toyota_tss2_field_present(self):
     assert "toyota_tss2" in CAPABILITY_FIELDS
 

openpilot/sunnypilot/sunnylink/tests/test_settings_changes.py

@@ -207,6 +207,7 @@ class TestNotEngagedReplacement(OpenpilotTestCase):
     "AlphaLongitudinalEnabled",
     "ToyotaEnforceStockLongitudinal",
     "ToyotaStopAndGoHack",
+    "ToyotaEnhancedBsm",
     "ToyotaTSS2Smooth",
   ], names=["key"])
   def test_offroad_only_replaced_with_not_engaged(self, schema, key):

openpilot/sunnypilot/sunnylink/tests/test_settings_schema.py

@@ -286,6 +286,7 @@ class TestKnownVehicleSettings(OpenpilotTestCase):
     keys = {i["key"] for i in _brand_items(schema["vehicle_settings"].get("toyota"))}
     assert "ToyotaEnforceStockLongitudinal" in keys
     assert "ToyotaStopAndGoHack" in keys
+    assert "ToyotaEnhancedBsm" in keys
     assert "ToyotaTSS2Smooth" in keys
 
   def test_tesla_has_coop_steering(self, schema):

release/ci/model_generator.py

@@ -13,41 +13,26 @@ from pathlib import Path
 from datetime import datetime, UTC
 
 
-_VERSION_REGEX = re.compile(r'^(?:\d+[a-zA-Z]+|\d+[vVbB]\d+|[vVbB]\d+|\d{4})$')
-_DECIMAL_VERSION_REGEX = re.compile(r'^([vVbB]?)(\d+(?:\.\d+)+)$')
-
-
-def _version(word: str) -> str | None:
-  match = _DECIMAL_VERSION_REGEX.match(word.strip('()[]{}.,;:'))
-  if match:
-    return match.group(1).upper() + match.group(2)
-  stripped = re.sub(r'[^a-zA-Z0-9]', '', word)
-  return stripped.upper() if _VERSION_REGEX.match(stripped) else None
-
-
-def _truncate(short_name: str) -> str:
-  return short_name[:8].rstrip('.')
-
-
 def create_short_name(full_name: str) -> str:
-  # Remove parentheses and extract alphanumeric words, keeping decimals for versioning
+  # Remove parentheses and extract alphanumeric words
   clean_name = re.sub(r'\([^)]*\)', '', full_name)
-  words = [re.sub(r'[^a-zA-Z0-9.]', '', word) for word in clean_name.split()]
-  words = [word for word in words if word]
+  words = [re.sub(r'[^a-zA-Z0-9]', '', word) for word in clean_name.split() if re.sub(r'[^a-zA-Z0-9]', '', word)]
 
   if len(words) == 1:
-    return _truncate((_version(words[0]) or words[0]).upper())
+    return words[0][:8].upper()
 
-  # Handle special case: Name + Version (e.g., "Word A1" -> "WordA1", "Model v1.1" -> "ModelV1.1")
-  if len(words) == 2 and re.match(r'^[A-Za-z]?\d+$', words[1]):
-    return _truncate((words[0] + (_version(words[1]) or words[1])).upper())
+  # Handle special case: Name + Version (e.g., "Word A1" -> "WordA1")
+  if len(words) == 2 and re.match(r'^[A-Za-z]\d+$', words[1]):
+    return (words[0] + words[1])[:8].upper()
 
   result = ""
   for word in words:
     # Version or number patterns
-    version = _version(word)
-    if version:
-      result += version
+    if (re.match(r'^\d+[a-zA-Z]+$', word) or
+        re.match(r'^\d+[vVbB]\d+$', word) or
+        re.match(r'^[vVbB]\d+$', word) or
+        re.match(r'^\d{4}$', word)):
+      result += word.upper()
     # All uppercase abbreviations (2-3 letters)
     elif re.match(r'^[A-Z]{2,3}$', word):
       result += word
@@ -60,7 +45,7 @@ def create_short_name(full_name: str) -> str:
       result += word
     else:
       result += word[0].upper()
-  return _truncate(result)
+  return result[:8]
 
 
 def create_pkl_name(full_name: str) -> str: