Improve and fixed cam services for somes devices

fastboot/device/usb_client.cpp

@@ -53,6 +53,16 @@ struct SsFuncDesc {
     struct usb_ss_ep_comp_descriptor sink_comp;
 } __attribute__((packed));
 
+struct DescV1 {
+    struct usb_functionfs_descs_head_v1 {
+        __le32 magic;
+        __le32 length;
+        __le32 fs_count;
+        __le32 hs_count;
+    } __attribute__((packed)) header;
+    struct FuncDesc fs_descs, hs_descs;
+} __attribute__((packed));
+
 struct DescV2 {
     struct usb_functionfs_descs_head_v2 header;
     // The rest of the structure depends on the flags in the header.
@@ -146,6 +156,46 @@ static struct SsFuncDesc ss_descriptors = {
                 },
 };
 
+static struct FuncDesc fs_descriptors_v1 = {
+        .intf = fastboot_interface,
+        .source =
+                {
+                        .bLength = sizeof(fs_descriptors_v1.source),
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 1 | USB_DIR_OUT,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                        .wMaxPacketSize = kMaxPacketSizeFs,
+                },
+        .sink =
+                {
+                        .bLength = sizeof(fs_descriptors_v1.sink),
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 2 | USB_DIR_IN,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                        .wMaxPacketSize = kMaxPacketSizeFs,
+                },
+};
+
+static struct FuncDesc hs_descriptors_v1 = {
+        .intf = fastboot_interface,
+        .source =
+                {
+                        .bLength = sizeof(hs_descriptors_v1.source),
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 1 | USB_DIR_OUT,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                        .wMaxPacketSize = kMaxPacketSizeHs,
+                },
+        .sink =
+                {
+                        .bLength = sizeof(hs_descriptors_v1.sink),
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 2 | USB_DIR_IN,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                        .wMaxPacketSize = kMaxPacketSizeHs,
+                },
+};
+
 #define STR_INTERFACE_ "fastbootd"
 
 static const struct {
@@ -169,6 +219,17 @@ static const struct {
                 },
 };
 
+static struct DescV1 v1_descriptor = {
+        .header = {
+            .magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC),
+            .length = htole32(sizeof(v1_descriptor)),
+            .fs_count = 3,
+            .hs_count = 3,
+        },
+        .fs_descs = fs_descriptors_v1,
+        .hs_descs = hs_descriptors_v1,
+};
+
 static struct DescV2 v2_descriptor = {
         .header =
                 {
@@ -205,8 +266,12 @@ static bool InitFunctionFs(usb_handle* h) {
 
         auto ret = write(h->control.get(), &v2_descriptor, sizeof(v2_descriptor));
         if (ret < 0) {
-            PLOG(ERROR) << "cannot write descriptors " << kUsbFfsFastbootEp0;
-            goto err;
+            // fallback to v1 descriptor, with different endpoint addresses for source and sink
+            ret = write(h->control.get(), &v1_descriptor, sizeof(v1_descriptor));
+            if (ret < 0) {
+                PLOG(ERROR) << "cannot write descriptors " << kUsbFfsFastbootEp0;
+                goto err;
+            }
         }
 
         ret = write(h->control.get(), &strings, sizeof(strings));

fastboot/device/utility.cpp

@@ -195,7 +195,7 @@ std::vector<std::string> ListPartitions(FastbootDevice* device) {
 }
 
 bool GetDeviceLockStatus() {
-    return android::base::GetProperty("ro.boot.verifiedbootstate", "") != "orange";
+    return android::base::GetProperty("ro.boot.verifiedbootstate", "") == "green";
 }
 
 bool UpdateAllPartitionMetadata(FastbootDevice* device, const std::string& super_name,

fastboot/device/variables.cpp

@@ -421,7 +421,10 @@ std::vector<std::vector<std::string>> GetAllPartitionArgsNoSlot(FastbootDevice*
 
 bool GetHardwareRevision(FastbootDevice* /* device */, const std::vector<std::string>& /* args */,
                          std::string* message) {
-    *message = android::base::GetProperty("ro.revision", "");
+    *message = android::base::GetProperty("ro.boot.hardware.revision", "");
+    if (message->empty()) {
+        *message = android::base::GetProperty("ro.revision", "");
+    }
     return true;
 }
 

fs_mgr/Android.bp

@@ -161,6 +161,11 @@ cc_library {
     srcs: [
         ":libfiemap_passthrough_srcs",
     ],
+    target: {
+        recovery: {
+            cflags: ["-DSKIP_SET_BLK_RO"],
+        },
+    },
 }
 
 cc_library {

fs_mgr/clean_scratch_files.rc

@@ -1,2 +1,2 @@
-on post-fs-data && property:ro.debuggable=1
+on post-fs-data && property:ro.debuggable=1 && property:ro.boot.dynamic_partitions=true
     exec_background - root root -- /system/bin/clean_scratch_files

fs_mgr/fs_mgr.cpp

@@ -845,9 +845,11 @@ static int __mount(const std::string& source, const std::string& target, const F
     }
     PINFO << __FUNCTION__ << "(source=" << source << source_missing << ",target=" << target
           << target_missing << ",type=" << entry.fs_type << ")=" << ret;
+#ifndef SKIP_SET_BLK_RO
     if ((ret == 0) && (mountflags & MS_RDONLY) != 0) {
         fs_mgr_set_blk_ro(source);
     }
+#endif
     if (ret == 0) {
         android::base::SetProperty("ro.boottime.init.mount." + Basename(target),
                                    std::to_string(t.duration().count()));

fs_mgr/fs_mgr_roots.cpp

@@ -123,15 +123,6 @@ bool TryPathMount(FstabEntry* rec, const std::string& mount_pt) {
     }
 
     int result = fs_mgr_do_mount_one(*rec, mount_point);
-    if (result == -1 && rec->fs_mgr_flags.formattable) {
-        PERROR << "Failed to mount " << mount_point << "; formatting";
-        if (fs_mgr_do_format(*rec) != 0) {
-            PERROR << "Failed to format " << mount_point;
-            return false;
-        }
-        result = fs_mgr_do_mount_one(*rec, mount_point);
-    }
-
     if (result == -1) {
         PERROR << "Failed to mount " << mount_point;
         return false;

fs_mgr/liblp/writer.cpp

@@ -138,8 +138,8 @@ static bool ValidateAndSerializeMetadata([[maybe_unused]] const IPartitionOpener
             PERROR << partition_name << ": ioctl";
             return false;
         }
-        if (info.size != block_device.size) {
-            LERROR << "Block device " << partition_name << " size mismatch (expected"
+        if (info.size < block_device.size) {
+            LERROR << "Block device " << partition_name << " size is too small (expected"
                    << block_device.size << ", got " << info.size << ")";
             return false;
         }

healthd/BatteryMonitor.cpp

@@ -304,13 +304,16 @@ static BatteryMonitor::PowerSupplyType readPowerSupplyType(const String8& path)
             {"USB", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_USB},
             {"USB_DCP", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_AC},
             {"USB_HVDCP", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_AC},
+            {"USB_HVDCP_3", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_AC},
+            {"USB_HVDCP_3P5", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_AC},
             {"USB_CDP", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_AC},
             {"USB_ACA", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_AC},
             {"USB_C", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_AC},
             {"USB_PD", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_AC},
             {"USB_PD_DRP", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_USB},
             {"Wireless", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_WIRELESS},
             {"Dock", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_DOCK},
+            {"DASH", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_AC},
             {NULL, 0},
     };
     std::string buf;
@@ -320,10 +323,8 @@ static BatteryMonitor::PowerSupplyType readPowerSupplyType(const String8& path)
     }
 
     auto ret = mapSysfsString(buf.c_str(), supplyTypeMap);
-    if (!ret) {
-        KLOG_WARNING(LOG_TAG, "Unknown power supply type '%s'\n", buf.c_str());
+    if (!ret)
         *ret = BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_UNKNOWN;
-    }
 
     return static_cast<BatteryMonitor::PowerSupplyType>(*ret);
 }
@@ -442,6 +443,52 @@ void BatteryMonitor::updateValues(void) {
 
     double MaxPower = 0;
 
+    // Rescan for the available charger types
+    std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(POWER_SUPPLY_SYSFS_PATH), closedir);
+    if (dir == NULL) {
+        KLOG_ERROR(LOG_TAG, "Could not open %s\n", POWER_SUPPLY_SYSFS_PATH);
+    } else {
+        struct dirent* entry;
+        String8 path;
+
+        mChargerNames.clear();
+
+        while ((entry = readdir(dir.get()))) {
+            const char* name = entry->d_name;
+
+            if (!strcmp(name, ".") || !strcmp(name, ".."))
+                continue;
+
+            // Look for "type" file in each subdirectory
+            path.clear();
+            path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH, name);
+            switch(readPowerSupplyType(path)) {
+            case ANDROID_POWER_SUPPLY_TYPE_AC:
+            case ANDROID_POWER_SUPPLY_TYPE_USB:
+            case ANDROID_POWER_SUPPLY_TYPE_WIRELESS:
+            case ANDROID_POWER_SUPPLY_TYPE_DOCK:
+                path.clear();
+                path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, name);
+                if (access(path.string(), R_OK) == 0)
+                    mChargerNames.add(String8(name));
+                break;
+            default:
+                break;
+            }
+
+            // Look for "is_dock" file
+            path.clear();
+            path.appendFormat("%s/%s/is_dock", POWER_SUPPLY_SYSFS_PATH, name);
+            if (access(path.string(), R_OK) == 0) {
+                path.clear();
+                path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, name);
+                if (access(path.string(), R_OK) == 0)
+                    mChargerNames.add(String8(name));
+
+            }
+        }
+    }
+
     for (size_t i = 0; i < mChargerNames.size(); i++) {
         String8 path;
         path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH,

init/Android.bp

@@ -91,6 +91,14 @@ init_host_sources = [
     "host_init_verifier.cpp",
 ]
 
+cc_library_static {
+    name: "vendor_init",
+    recovery_available: true,
+    srcs: [
+        "vendor_init.cpp",
+    ],
+}
+
 soong_config_module_type {
     name: "libinit_cc_defaults",
     module_type: "cc_defaults",
@@ -219,6 +227,7 @@ cc_library_static {
     defaults: [
         "init_defaults",
         "selinux_policy_version",
+        "vendor_init_defaults",
     ],
     srcs: init_common_sources + init_device_sources,
     export_include_dirs: ["."],

init/NOTICE

@@ -188,3 +188,29 @@
 
    END OF TERMS AND CONDITIONS
 
+Copyright (c) 2013, The Linux Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of The Linux Foundation nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

init/first_stage_mount.cpp

@@ -419,9 +419,14 @@ bool FirstStageMount::MountPartition(const Fstab::iterator& begin, bool erase_sa
             return false;
         }
     }
-    if (!SetUpDmVerity(&(*begin))) {
-        PLOG(ERROR) << "Failed to setup verity for '" << begin->mount_point << "'";
-        return false;
+
+    if (begin->fs_mgr_flags.avb) {
+        if (!SetUpDmVerity(&(*begin))) {
+            PLOG(ERROR) << "Failed to setup verity for '" << begin->mount_point << "'";
+            return false;
+        }
+    } else {
+        LOG(INFO) << "AVB is not enabled, skip verity setup for '" << begin->mount_point << "'";
     }
 
     bool mounted = (fs_mgr_do_mount_one(*begin) == 0);