diff --git a/libc/include/android/legacy_termios_inlines.h b/libc/include/android/legacy_termios_inlines.h
index 9ea588d..6222786 100644
--- a/libc/include/android/legacy_termios_inlines.h
+++ b/libc/include/android/legacy_termios_inlines.h
@@ -30,7 +30,10 @@
 
 #include <sys/cdefs.h>
 
-#if __ANDROID_API__ < 21
+// The last bugfixes to <bits/termios_inlines.h> were
+// 5da96467a99254c963aef44e75167661d3e02278, so even those these functions were
+// in API level 21, ensure that everyone's using the latest versions.
+#if __ANDROID_API__ < 28
 
 #include <linux/termios.h>
 #include <sys/ioctl.h>
diff --git a/libc/include/termios.h b/libc/include/termios.h
index 8eca96e..e3f388c 100644
--- a/libc/include/termios.h
+++ b/libc/include/termios.h
@@ -40,8 +40,10 @@
 
 __BEGIN_DECLS
 
-#if __ANDROID_API__ >= 21
-// This file is implemented as static inlines before API level 21.
+#if __ANDROID_API__ >= 28
+// This file is implemented as static inlines before API level 28.
+// Strictly these functions were introduced in API level 21, but there were bugs
+// in cfmakeraw() and cfsetspeed() until 28.
 
 /**
  * [cfgetispeed(3)](http://man7.org/linux/man-pages/man3/cfgetispeed.3.html)
