initial commit

This is a port of the Android bootctrl HAL and Qualcomms GPT based
implementation for musl/glibc based systems running mainline linux

Currently it doesn't work because the gpt hdr which is read doesn't
seem to have valid data.

.gitignore

@@ -0,0 +1,2 @@
+.vscode/
+build/

BootControl.cpp

@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string>
+
+#include "boot_control.h"
+#include "BootControl.h"
+
+BootControl::BootControl(boot_control_module *module) : mModule(module) {
+}
+
+// Methods from ::android::hardware::boot::V1_0::IBootControl follow.
+unsigned int BootControl::getNumberSlots()  {
+    return mModule->getNumberSlots(mModule);
+}
+
+unsigned int BootControl::getCurrentSlot()  {
+    return mModule->getCurrentSlot(mModule);
+}
+
+int BootControl::markBootSuccessful()  {
+    int ret = mModule->markBootSuccessful(mModule);
+    return ret;
+}
+
+int BootControl::setActiveBootSlot(unsigned int slot)  {
+    int ret = mModule->setActiveBootSlot(mModule, slot);
+    return ret;
+}
+
+int BootControl::setSlotAsUnbootable(unsigned int slot)  {
+    int ret = mModule->setSlotAsUnbootable(mModule, slot);
+    return ret;
+}
+
+BoolResult BootControl::isSlotBootable(unsigned int slot)  {
+    int32_t ret = mModule->isSlotBootable(mModule, slot);
+    if (ret < 0) {
+        return BoolResult::INVALID_SLOT;
+    }
+    return ret ? BoolResult::TRUE : BoolResult::FALSE;
+}
+
+BoolResult BootControl::isSlotMarkedSuccessful(unsigned int slot)  {
+    int32_t ret = mModule->isSlotMarkedSuccessful(mModule, slot);
+    if (ret < 0) {
+        return BoolResult::INVALID_SLOT;
+    }
+    return ret ? BoolResult::TRUE : BoolResult::FALSE;
+}
+
+std::string BootControl::getSuffix(unsigned int slot)  {
+    std::string ans;
+    const char *suffix = mModule->getSuffix(mModule, slot);
+    if (suffix) {
+        ans = std::string(suffix);
+    }
+    return ans;
+}
+
+BootControl* BootControlInit() {
+    boot_control_module* module;
+
+    // For devices that don't build a standalone libhardware bootctrl impl for recovery,
+    // we simulate the hw_get_module() by accessing it from the current process directly.
+    const boot_control_module* hw_module = &HAL_MODULE_INFO_SYM;
+    module = reinterpret_cast<boot_control_module*>(const_cast<boot_control_module*>(hw_module));
+    module->init(module);
+    return new BootControl(module);
+}
+
+int main (int argc, char * argv []) {
+    BootControl *bootctl = BootControlInit();
+    printf("======= Current slot: %d\n", bootctl->getCurrentSlot());
+    printf("======= isslotbootable: a = %d, b = %d\n", bootctl->isSlotBootable(0),
+    bootctl->isSlotBootable(1));
+    printf("======= isSlotMarkedSuccessful: a = %d, b = %d\n", bootctl->isSlotMarkedSuccessful(0),
+    bootctl->isSlotMarkedSuccessful(1));
+}

BootControl.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef ANDROID_HARDWARE_BOOT_V1_0_BOOTCONTROL_H
+#define ANDROID_HARDWARE_BOOT_V1_0_BOOTCONTROL_H
+
+/**
+ * A result encapsulating whether a function returned true, false or
+ * failed due to an invalid slot number
+ */
+enum class BoolResult : int {
+    FALSE = 0,
+    TRUE = 1,
+    INVALID_SLOT = -1 /* -1 */,
+};
+
+struct BootControl {
+    BootControl(boot_control_module* module);
+    // Methods from ::android::hardware::boot::V1_0::IBootControl follow.
+    unsigned int getNumberSlots();
+    unsigned int getCurrentSlot();
+    int markBootSuccessful();
+    int setActiveBootSlot(unsigned int slot);
+    int setSlotAsUnbootable(unsigned int slot);
+    BoolResult isSlotBootable(unsigned int slot);
+    BoolResult isSlotMarkedSuccessful(unsigned int slot);
+    std::string getSuffix(unsigned int slot);
+private:
+    boot_control_module* mModule;
+};
+
+
+#endif  // ANDROID_HARDWARE_BOOT_V1_0_BOOTCONTROL_H

CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.10)
+
+# set the project name
+project(qbootctl)
+
+set(BootCtrl_Files BootControl.cpp
+        boot_control_impl_qcom.cpp
+        gpt-utils.cpp)
+
+include_directories(include)
+
+# add the executable
+add_executable(qbootctl ${BootCtrl_Files})
+
+target_link_libraries(qbootctl libz.so)

README.md

@@ -0,0 +1,7 @@
+Qualcomm bootctl HAL for Linux
+
+This HAL was pulled from AOSP source code and bastardised to build and run on a musl/glibc system. This may or may not render any hardware you run it on unusable, you have been warned.
+
+# Dependencies
+
+* zlib-dev

boot_control.h

@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_INCLUDE_HARDWARE_BOOT_CONTROL_H
+#define ANDROID_INCLUDE_HARDWARE_BOOT_CONTROL_H
+
+#define BOOT_CONTROL_MODULE_API_VERSION_0_1  HARDWARE_MODULE_API_VERSION(0, 1)
+
+/**
+ * The id of this module
+ */
+#define BOOT_CONTROL_HARDWARE_MODULE_ID "bootctrl"
+
+/*
+ * The Boot Control HAL is designed to allow for managing sets of redundant
+ * partitions, called slots, that can be booted from independantly. Slots
+ * are sets of partitions whose names differ only by a given suffix.
+ * They are identified here by a 0 indexed number, and associated with their
+ * suffix, which can be appended to the base name for any particular partition
+ * to find the one associated with that slot. The bootloader must pass the suffix
+ * of the currently active slot either through a kernel command line property at
+ * androidboot.slot_suffix, or the device tree at /firmware/android/slot_suffix.
+ * The primary use of this set up is to allow for background updates while the
+ * device is running, and to provide a fallback in the event that the update fails.
+ */
+
+
+/**
+ * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
+ * and the fields of this data structure must begin with hw_module_t
+ * followed by module specific information.
+ */
+struct boot_control_module {
+
+    /*
+     * (*init)() perform any initialization tasks needed for the HAL.
+     * This is called only once.
+     */
+    void (*init)(struct boot_control_module *module);
+
+    /*
+     * (*getNumberSlots)() returns the number of available slots.
+     * For instance, a system with a single set of partitions would return
+     * 1, a system with A/B would return 2, A/B/C -> 3...
+     */
+    unsigned (*getNumberSlots)(struct boot_control_module *module);
+
+    /*
+     * (*getCurrentSlot)() returns the value letting the system know
+     * whether the current slot is A or B. The meaning of A and B is
+     * left up to the implementer. It is assumed that if the current slot
+     * is A, then the block devices underlying B can be accessed directly
+     * without any risk of corruption.
+     * The returned value is always guaranteed to be strictly less than the
+     * value returned by getNumberSlots. Slots start at 0 and
+     * finish at getNumberSlots() - 1
+     */
+    unsigned (*getCurrentSlot)(struct boot_control_module *module);
+
+    /*
+     * (*markBootSuccessful)() marks the current slot
+     * as having booted successfully
+     *
+     * Returns 0 on success, -errno on error.
+     */
+    int (*markBootSuccessful)(struct boot_control_module *module);
+
+    /*
+     * (*setActiveBootSlot)() marks the slot passed in parameter as
+     * the active boot slot (see getCurrentSlot for an explanation
+     * of the "slot" parameter). This overrides any previous call to
+     * setSlotAsUnbootable.
+     * Returns 0 on success, -errno on error.
+     */
+    int (*setActiveBootSlot)(struct boot_control_module *module, unsigned slot);
+
+    /*
+     * (*setSlotAsUnbootable)() marks the slot passed in parameter as
+     * an unbootable. This can be used while updating the contents of the slot's
+     * partitions, so that the system will not attempt to boot a known bad set up.
+     * Returns 0 on success, -errno on error.
+     */
+    int (*setSlotAsUnbootable)(struct boot_control_module *module, unsigned slot);
+
+    /*
+     * (*isSlotBootable)() returns if the slot passed in parameter is
+     * bootable. Note that slots can be made unbootable by both the
+     * bootloader and by the OS using setSlotAsUnbootable.
+     * Returns 1 if the slot is bootable, 0 if it's not, and -errno on
+     * error.
+     */
+    int (*isSlotBootable)(struct boot_control_module *module, unsigned slot);
+
+    /*
+     * (*getSuffix)() returns the string suffix used by partitions that
+     * correspond to the slot number passed in parameter. The returned string
+     * is expected to be statically allocated and not need to be freed.
+     * Returns NULL if slot does not match an existing slot.
+     */
+    const char* (*getSuffix)(struct boot_control_module *module, unsigned slot);
+
+    /*
+     * (*isSlotMarkedSucessful)() returns if the slot passed in parameter has
+     * been marked as successful using markBootSuccessful.
+     * Returns 1 if the slot has been marked as successful, 0 if it's
+     * not the case, and -errno on error.
+     */
+    int (*isSlotMarkedSuccessful)(struct boot_control_module *module, unsigned slot);
+
+    /**
+     * Returns the active slot to boot into on the next boot. If
+     * setActiveBootSlot() has been called, the getter function should return
+     * the same slot as the one provided in the last setActiveBootSlot() call.
+     */
+    unsigned (*getActiveBootSlot)(struct boot_control_module *module);
+
+    void* reserved[30];
+};
+
+extern const struct boot_control_module HAL_MODULE_INFO_SYM;
+
+
+#endif  // ANDROID_INCLUDE_HARDWARE_BOOT_CONTROL_H

gpt-utils.h

@@ -0,0 +1,196 @@
+/*
+ * 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.
+ */
+
+#ifndef __GPT_UTILS_H__
+#define __GPT_UTILS_H__
+#include <vector>
+#include <string>
+#include <map>
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <unistd.h>
+#include <stdlib.h>
+/******************************************************************************
+ * GPT HEADER DEFINES
+ ******************************************************************************/
+#define GPT_SIGNATURE               "EFI PART"
+#define HEADER_SIZE_OFFSET          12
+#define HEADER_CRC_OFFSET           16
+#define PRIMARY_HEADER_OFFSET       24
+#define BACKUP_HEADER_OFFSET        32
+#define FIRST_USABLE_LBA_OFFSET     40
+#define LAST_USABLE_LBA_OFFSET      48
+#define PENTRIES_OFFSET             72
+#define PARTITION_COUNT_OFFSET      80
+#define PENTRY_SIZE_OFFSET          84
+#define PARTITION_CRC_OFFSET        88
+
+#define TYPE_GUID_OFFSET            0
+#define TYPE_GUID_SIZE              16
+#define PTN_ENTRY_SIZE              128
+#define UNIQUE_GUID_OFFSET          16
+#define FIRST_LBA_OFFSET            32
+#define LAST_LBA_OFFSET             40
+#define ATTRIBUTE_FLAG_OFFSET       48
+#define PARTITION_NAME_OFFSET       56
+#define MAX_GPT_NAME_SIZE           72
+
+/******************************************************************************
+ * AB RELATED DEFINES
+ ******************************************************************************/
+//Bit 48 onwords in the attribute field are the ones where we are allowed to
+//store our AB attributes.
+#define AB_FLAG_OFFSET (ATTRIBUTE_FLAG_OFFSET + 6)
+#define GPT_DISK_INIT_MAGIC 0xABCD
+#define AB_PARTITION_ATTR_SLOT_ACTIVE (0x1<<2)
+#define AB_PARTITION_ATTR_BOOT_SUCCESSFUL (0x1<<6)
+#define AB_PARTITION_ATTR_UNBOOTABLE (0x1<<7)
+#define AB_SLOT_ACTIVE_VAL              0xF
+#define AB_SLOT_INACTIVE_VAL            0x0
+#define AB_SLOT_ACTIVE                  1
+#define AB_SLOT_INACTIVE                0
+#define AB_SLOT_A_SUFFIX                "_a"
+#define AB_SLOT_B_SUFFIX                "_b"
+#define PTN_XBL                         "xbl"
+#define PTN_SWAP_LIST                   PTN_XBL, \
+            "abl", "aop", "apdp", "cmnlib", "cmnlib64", \
+            "devcfg", "dtbo", "hyp", "keymaster", "msadp", \
+            "qupfw", "storsec", "tz", "vbmeta", "vbmeta_system", "xbl_config"
+
+#define AB_PTN_LIST PTN_SWAP_LIST, "boot", "system", "vendor", "modem", "system_ext", "product"
+#define BOOT_DEV_DIR    "/dev/disk/by-partlabel"
+
+/******************************************************************************
+ * HELPER MACROS
+ ******************************************************************************/
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+/******************************************************************************
+ * TYPES
+ ******************************************************************************/
+enum boot_update_stage {
+	UPDATE_MAIN = 1,
+	UPDATE_BACKUP,
+	UPDATE_FINALIZE
+};
+
+enum gpt_instance {
+	PRIMARY_GPT = 0,
+	SECONDARY_GPT
+};
+
+enum boot_chain {
+	NORMAL_BOOT = 0,
+	BACKUP_BOOT
+};
+
+struct gpt_disk {
+	//GPT primary header
+	uint8_t *hdr;
+	//primary header crc
+	uint32_t hdr_crc;
+	//GPT backup header
+	uint8_t *hdr_bak;
+	//backup header crc
+	uint32_t hdr_bak_crc;
+	//Partition entries array
+	uint8_t *pentry_arr;
+	//Partition entries array for backup table
+	uint8_t *pentry_arr_bak;
+	//Size of the pentry array
+	uint32_t pentry_arr_size;
+	//Size of each element in the pentry array
+	uint32_t pentry_size;
+	//CRC of the partition entry array
+	uint32_t pentry_arr_crc;
+	//CRC of the backup partition entry array
+	uint32_t pentry_arr_bak_crc;
+	//Path to block dev representing the disk
+	char devpath[PATH_MAX];
+	//Block size of disk
+	uint32_t block_size;
+	uint32_t is_initialized;
+};
+
+/******************************************************************************
+ * FUNCTION PROTOTYPES
+ ******************************************************************************/
+int prepare_boot_update(enum boot_update_stage stage);
+//GPT disk methods
+struct gpt_disk* gpt_disk_alloc();
+//Free previously allocated gpt_disk struct
+void gpt_disk_free(struct gpt_disk *disk);
+//Get the details of the disk holding the partition whose name
+//is passed in via dev
+int gpt_disk_get_disk_info(const char *dev, struct gpt_disk *disk);
+
+//Get pointer to partition entry from a allocated gpt_disk structure
+uint8_t* gpt_disk_get_pentry(struct gpt_disk *disk,
+		const char *partname,
+		enum gpt_instance instance);
+
+//Update the crc fields of the modified disk structure
+int gpt_disk_update_crc(struct gpt_disk *disk);
+
+//Write the contents of struct gpt_disk back to the actual disk
+int gpt_disk_commit(struct gpt_disk *disk);
+
+//Return if the current device is UFS based or not
+int gpt_utils_is_ufs_device();
+
+//Swtich betwieen using either the primary or the backup
+//boot LUN for boot. This is required since UFS boot partitions
+//cannot have a backup GPT which is what we use for failsafe
+//updates of the other 'critical' partitions. This function will
+//not be invoked for emmc targets and on UFS targets is only required
+//to be invoked for XBL.
+//
+//The algorithm to do this is as follows:
+//- Find the real block device(eg: /dev/block/sdb) that corresponds
+//  to the /dev/block/bootdevice/by-name/xbl(bak) symlink
+//
+//- Once we have the block device 'node' name(sdb in the above example)
+//  use this node to to locate the scsi generic device that represents
+//  it by checking the file /sys/block/sdb/device/scsi_generic/sgY
+//
+//- Once we locate sgY we call the query ioctl on /dev/sgy to switch
+//the boot lun to either LUNA or LUNB
+int gpt_utils_set_xbl_boot_partition(enum boot_chain chain);
+
+//Given a vector of partition names as a input and a reference to a map,
+//populate the map to indicate which physical disk each of the partitions
+//sits on. The key in the map is the path to the block device where the
+//partition lies and the value is a vector of strings indicating which of
+//the passed in partition names sits on that device.
+int gpt_utils_get_partition_map(std::vector<std::string>& partition_list,
+                std::map<std::string,std::vector<std::string>>& partition_map);
+#ifdef __cplusplus
+}
+#endif
+#endif /* __GPT_UTILS_H__ */

include/scsi/ufs/ioctl.h

@@ -0,0 +1,30 @@
+/****************************************************************************
+ ****************************************************************************
+ ***
+ ***   This header was automatically generated from a Linux kernel header
+ ***   of the same name, to make information necessary for userspace to
+ ***   call into the kernel available to libc.  It contains only constants,
+ ***   structures, and macros generated from the original header, and thus,
+ ***   contains no copyrightable information.
+ ***
+ ***   To edit the content of this header, modify the corresponding
+ ***   source file (e.g. under external/kernel-headers/original/) then
+ ***   run bionic/libc/kernel/tools/update_all.py
+ ***
+ ***   Any manual change here will be lost the next time this script will
+ ***   be run. You've been warned!
+ ***
+ ****************************************************************************
+ ****************************************************************************/
+#ifndef UAPI_UFS_IOCTL_H_
+#define UAPI_UFS_IOCTL_H_
+#include <linux/types.h>
+#define UFS_IOCTL_QUERY 0x5388
+struct ufs_ioctl_query_data {
+  __u32 opcode;
+  __u8 idn;
+  __u16 buf_size;
+  __u8 buffer[0];
+};
+#endif
+

include/scsi/ufs/ufs.h

@@ -0,0 +1,86 @@
+/****************************************************************************
+ ****************************************************************************
+ ***
+ ***   This header was automatically generated from a Linux kernel header
+ ***   of the same name, to make information necessary for userspace to
+ ***   call into the kernel available to libc.  It contains only constants,
+ ***   structures, and macros generated from the original header, and thus,
+ ***   contains no copyrightable information.
+ ***
+ ***   To edit the content of this header, modify the corresponding
+ ***   source file (e.g. under external/kernel-headers/original/) then
+ ***   run bionic/libc/kernel/tools/update_all.py
+ ***
+ ***   Any manual change here will be lost the next time this script will
+ ***   be run. You've been warned!
+ ***
+ ****************************************************************************
+ ****************************************************************************/
+#ifndef UAPI_UFS_H_
+#define UAPI_UFS_H_
+#define MAX_QUERY_IDN 0x18
+enum flag_idn {
+  QUERY_FLAG_IDN_FDEVICEINIT = 0x01,
+  QUERY_FLAG_IDN_PERMANENT_WPE = 0x02,
+  QUERY_FLAG_IDN_PWR_ON_WPE = 0x03,
+  QUERY_FLAG_IDN_BKOPS_EN = 0x04,
+  QUERY_FLAG_IDN_RESERVED1 = 0x05,
+  QUERY_FLAG_IDN_PURGE_ENABLE = 0x06,
+  QUERY_FLAG_IDN_RESERVED2 = 0x07,
+  QUERY_FLAG_IDN_FPHYRESOURCEREMOVAL = 0x08,
+  QUERY_FLAG_IDN_BUSY_RTC = 0x09,
+  QUERY_FLAG_IDN_MANUAL_GC_CONT = 0x0E,
+};
+enum attr_idn {
+  QUERY_ATTR_IDN_BOOT_LU_EN = 0x00,
+  QUERY_ATTR_IDN_RESERVED = 0x01,
+  QUERY_ATTR_IDN_POWER_MODE = 0x02,
+  QUERY_ATTR_IDN_ACTIVE_ICC_LVL = 0x03,
+  QUERY_ATTR_IDN_OOO_DATA_EN = 0x04,
+  QUERY_ATTR_IDN_BKOPS_STATUS = 0x05,
+  QUERY_ATTR_IDN_PURGE_STATUS = 0x06,
+  QUERY_ATTR_IDN_MAX_DATA_IN = 0x07,
+  QUERY_ATTR_IDN_MAX_DATA_OUT = 0x08,
+  QUERY_ATTR_IDN_DYN_CAP_NEEDED = 0x09,
+  QUERY_ATTR_IDN_REF_CLK_FREQ = 0x0A,
+  QUERY_ATTR_IDN_CONF_DESC_LOCK = 0x0B,
+  QUERY_ATTR_IDN_MAX_NUM_OF_RTT = 0x0C,
+  QUERY_ATTR_IDN_EE_CONTROL = 0x0D,
+  QUERY_ATTR_IDN_EE_STATUS = 0x0E,
+  QUERY_ATTR_IDN_SECONDS_PASSED = 0x0F,
+  QUERY_ATTR_IDN_CNTX_CONF = 0x10,
+  QUERY_ATTR_IDN_CORR_PRG_BLK_NUM = 0x11,
+  QUERY_ATTR_IDN_MANUAL_GC_STATUS = 0x17,
+};
+#define QUERY_ATTR_IDN_BOOT_LU_EN_MAX 0x02
+enum desc_idn {
+  QUERY_DESC_IDN_DEVICE = 0x0,
+  QUERY_DESC_IDN_CONFIGURAION = 0x1,
+  QUERY_DESC_IDN_UNIT = 0x2,
+  QUERY_DESC_IDN_RFU_0 = 0x3,
+  QUERY_DESC_IDN_INTERCONNECT = 0x4,
+  QUERY_DESC_IDN_STRING = 0x5,
+  QUERY_DESC_IDN_RFU_1 = 0x6,
+  QUERY_DESC_IDN_GEOMETRY = 0x7,
+  QUERY_DESC_IDN_POWER = 0x8,
+  QUERY_DESC_IDN_HEALTH = 0x9,
+  QUERY_DESC_IDN_RFU_2 = 0xA,
+  QUERY_DESC_IDN_MAX,
+};
+enum query_opcode {
+  UPIU_QUERY_OPCODE_NOP = 0x0,
+  UPIU_QUERY_OPCODE_READ_DESC = 0x1,
+  UPIU_QUERY_OPCODE_WRITE_DESC = 0x2,
+  UPIU_QUERY_OPCODE_READ_ATTR = 0x3,
+  UPIU_QUERY_OPCODE_WRITE_ATTR = 0x4,
+  UPIU_QUERY_OPCODE_READ_FLAG = 0x5,
+  UPIU_QUERY_OPCODE_SET_FLAG = 0x6,
+  UPIU_QUERY_OPCODE_CLEAR_FLAG = 0x7,
+  UPIU_QUERY_OPCODE_TOGGLE_FLAG = 0x8,
+  UPIU_QUERY_OPCODE_MAX,
+};
+#define UPIU_QUERY_OPCODE_HIGH_HPB 0x5500
+#define UPIU_QUERY_OPCODE_HIGH(opcode) ((opcode) >> 16)
+#define UPIU_QUERY_OPCODE_LOW(opcode) ((opcode) & 0xffff)
+#endif
+