pmbootstrap init: kernel selection / remove linux-pmos-lts (#1363)

* As discussed in IRC/matrix, we're removing `linux-postmarketos-lts`
  for now. The kernel isn't used right now, and we save lots of
  maintenance effort with not updating it every week or so.
* new config option `"kernel"` with possible values:
  `"downstream", "mainline", "stable"` (downstream is always
  `linux-$devicename`)
* ask for the kernel during `pmbootstrap init` if the device package
  has kernel subpackages and install it in `_install.py`
* postmarketos-mkinitfs: display note instead of exit with error when
  the `deviceinfo_dtb` file is missing (because we expect it to be
  missing for downstream kernels)
* device-sony-amami:
  * add kernel subpackages for downstream, mainline
  * set `deviceinfo_dtb`
* device-qemu-amd64: add kernel subpackages for stable, lts, mainline
* test cases and test data for new functions
* test case that checks all aports for right usage of the feature:
  * don't mix specifying kernels in depends *and* subpackages
  * 1 kernel in depends is maximum
  * kernel subpackages must have a valid name
  * Test if devices packages reference at least one kernel
* Remove `_build_device_depends_note()` which informs the user that
  `--ignore-depends` can be used with device packages to avoid building
  the kernel. The idea was to make the transition easier after a change
  we did months ago, and now the kernel doesn't always get built before
  building the device package so it's not relevant anymore.
* pmb/chroot/other.py:
  * Add autoinstall=True to kernel_flavors_installed(). When the flag
    is set, the function makes sure that at least one kernel for the
    device is installed.
  * Remove kernel_flavor_autodetect() function, wherever it was used,
    it has been replaced with kernel_flavors_installed()[0].
* pmb.helpers.frontend.py: remove code to install at least one kernel,
  kernel_flavors_installed() takes care of that now.

pmb/config/init.py

@@ -124,6 +124,47 @@ def ask_for_timezone(args):
     return "GMT"
 
 
+def ask_for_device_kernel(args, device):
+    """
+    Ask for the kernel that should be used with the device.
+
+    :param device: code name, e.g. "lg-mako"
+    :returns: None if the kernel is hardcoded in depends without subpackages
+    :returns: kernel type ("downstream", "stable", "mainline", ...)
+    """
+    # Get kernels
+    kernels = pmb.parse._apkbuild.kernels(args, device)
+    if not kernels:
+        return args.kernel
+
+    # Get default
+    default = args.kernel
+    if default not in kernels:
+        default = list(kernels.keys())[0]
+
+    # Ask for kernel (extra message when downstream and upstream are available)
+    logging.info("Which kernel do you want to use with your device?")
+    if "downstream" in kernels:
+        logging.info("Downstream kernels are typically the outdated Android"
+                     " kernel forks.")
+    if "downstream" in kernels and len(kernels) > 1:
+        logging.info("Upstream kernels (mainline, stable, ...) get security"
+                     " updates, but may have less working features than"
+                     " downstream kernels.")
+
+    # List kernels
+    logging.info("Available kernels (" + str(len(kernels)) + "):")
+    for type in sorted(kernels.keys()):
+        logging.info("* " + type + ": " + kernels[type])
+    while True:
+        ret = pmb.helpers.cli.ask(args, "Kernel", None, default, True)
+        if ret in kernels.keys():
+            return ret
+        logging.fatal("ERROR: Invalid kernel specified, please type in one"
+                      " from the list above.")
+    return ret
+
+
 def ask_for_device_nonfree(args, device):
     """
     Ask the user about enabling proprietary firmware (e.g. Wifi) and userland
@@ -190,8 +231,9 @@ def ask_for_device(args):
             pmb.aportgen.generate(args, "linux-" + device)
         break
 
+    kernel = ask_for_device_kernel(args, device)
     nonfree = ask_for_device_nonfree(args, device)
-    return (device, device_exists, nonfree)
+    return (device, device_exists, kernel, nonfree)
 
 
 def ask_for_qemu_native_mesa_driver(args, device, arch_native):
@@ -259,8 +301,9 @@ def frontend(args):
     cfg["pmbootstrap"]["work"] = args.work = ask_for_work_path(args)
 
     # Device
-    device, device_exists, nonfree = ask_for_device(args)
+    device, device_exists, kernel, nonfree = ask_for_device(args)
     cfg["pmbootstrap"]["device"] = device
+    cfg["pmbootstrap"]["kernel"] = kernel
     cfg["pmbootstrap"]["nonfree_firmware"] = str(nonfree["firmware"])
     cfg["pmbootstrap"]["nonfree_userland"] = str(nonfree["userland"])