273 lines
13 KiB
Java
273 lines
13 KiB
Java
/*
|
|
* Copyright (C) 2018 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.
|
|
*/
|
|
|
|
package com.android.internal.usb;
|
|
|
|
import static android.hardware.usb.UsbPort.FLAG_ALT_MODE_TYPE_DISPLAYPORT;
|
|
import static android.hardware.usb.UsbPortStatus.MODE_AUDIO_ACCESSORY;
|
|
import static android.hardware.usb.UsbPortStatus.MODE_DEBUG_ACCESSORY;
|
|
import static android.hardware.usb.UsbPortStatus.MODE_DFP;
|
|
import static android.hardware.usb.UsbPortStatus.MODE_DUAL;
|
|
import static android.hardware.usb.UsbPortStatus.MODE_NONE;
|
|
import static android.hardware.usb.UsbPortStatus.MODE_UFP;
|
|
|
|
import static com.android.internal.util.dump.DumpUtils.writeStringIfNotNull;
|
|
|
|
import android.annotation.NonNull;
|
|
import android.hardware.usb.DisplayPortAltModeInfo;
|
|
import android.hardware.usb.UsbAccessory;
|
|
import android.hardware.usb.UsbConfiguration;
|
|
import android.hardware.usb.UsbDevice;
|
|
import android.hardware.usb.UsbEndpoint;
|
|
import android.hardware.usb.UsbInterface;
|
|
import android.hardware.usb.UsbPort;
|
|
import android.hardware.usb.UsbPortStatus;
|
|
import android.hardware.usb.V1_0.Constants;
|
|
import android.service.usb.UsbAccessoryProto;
|
|
import android.service.usb.UsbConfigurationProto;
|
|
import android.service.usb.UsbDeviceProto;
|
|
import android.service.usb.UsbEndPointProto;
|
|
import android.service.usb.UsbInterfaceProto;
|
|
import android.service.usb.UsbPortProto;
|
|
import android.service.usb.UsbPortStatusProto;
|
|
import android.service.usb.UsbPortStatusRoleCombinationProto;
|
|
|
|
import com.android.internal.util.dump.DualDumpOutputStream;
|
|
|
|
/** Dump methods for public USB classes */
|
|
public class DumpUtils {
|
|
public static void writeAccessory(@NonNull DualDumpOutputStream dump, @NonNull String idName,
|
|
long id, @NonNull UsbAccessory accessory) {
|
|
long token = dump.start(idName, id);
|
|
|
|
dump.write("manufacturer", UsbAccessoryProto.MANUFACTURER, accessory.getManufacturer());
|
|
dump.write("model", UsbAccessoryProto.MODEL, accessory.getModel());
|
|
writeStringIfNotNull(dump, "description", UsbAccessoryProto.DESCRIPTION,
|
|
accessory.getManufacturer());
|
|
dump.write("version", UsbAccessoryProto.VERSION, accessory.getVersion());
|
|
writeStringIfNotNull(dump, "uri", UsbAccessoryProto.URI, accessory.getUri());
|
|
dump.write("serial", UsbAccessoryProto.SERIAL, accessory.getSerial());
|
|
|
|
dump.end(token);
|
|
}
|
|
|
|
public static void writeDevice(@NonNull DualDumpOutputStream dump, @NonNull String idName,
|
|
long id, @NonNull UsbDevice device) {
|
|
long token = dump.start(idName, id);
|
|
|
|
dump.write("name", UsbDeviceProto.NAME, device.getDeviceName());
|
|
dump.write("vendor_id", UsbDeviceProto.VENDOR_ID, device.getVendorId());
|
|
dump.write("product_id", UsbDeviceProto.PRODUCT_ID, device.getProductId());
|
|
dump.write("class", UsbDeviceProto.CLASS, device.getDeviceClass());
|
|
dump.write("subclass", UsbDeviceProto.SUBCLASS, device.getDeviceSubclass());
|
|
dump.write("protocol", UsbDeviceProto.PROTOCOL, device.getDeviceProtocol());
|
|
dump.write("manufacturer_name", UsbDeviceProto.MANUFACTURER_NAME,
|
|
device.getManufacturerName());
|
|
dump.write("product_name", UsbDeviceProto.PRODUCT_NAME, device.getProductName());
|
|
dump.write("version", UsbDeviceProto.VERSION, device.getVersion());
|
|
dump.write("serial_number", UsbDeviceProto.SERIAL_NUMBER, device.getSerialNumber());
|
|
|
|
int numConfigurations = device.getConfigurationCount();
|
|
for (int i = 0; i < numConfigurations; i++) {
|
|
writeConfiguration(dump, "configurations", UsbDeviceProto.CONFIGURATIONS,
|
|
device.getConfiguration(i));
|
|
}
|
|
|
|
dump.end(token);
|
|
}
|
|
|
|
private static void writeConfiguration(@NonNull DualDumpOutputStream dump,
|
|
@NonNull String idName, long id, @NonNull UsbConfiguration configuration) {
|
|
long token = dump.start(idName, id);
|
|
dump.write("id", UsbConfigurationProto.ID, configuration.getId());
|
|
dump.write("name", UsbConfigurationProto.NAME, configuration.getName());
|
|
dump.write("attributes", UsbConfigurationProto.ATTRIBUTES, configuration.getAttributes());
|
|
dump.write("max_power", UsbConfigurationProto.MAX_POWER, configuration.getMaxPower());
|
|
|
|
int numInterfaces = configuration.getInterfaceCount();
|
|
for (int i = 0; i < numInterfaces; i++) {
|
|
writeInterface(dump, "interfaces", UsbConfigurationProto.INTERFACES,
|
|
configuration.getInterface(i));
|
|
}
|
|
dump.end(token);
|
|
}
|
|
|
|
private static void writeInterface(@NonNull DualDumpOutputStream dump, @NonNull String idName,
|
|
long id, @NonNull UsbInterface iface) {
|
|
long token = dump.start(idName, id);
|
|
|
|
dump.write("id", UsbInterfaceProto.ID, iface.getId());
|
|
dump.write("alternate_settings", UsbInterfaceProto.ALTERNATE_SETTINGS,
|
|
iface.getAlternateSetting());
|
|
dump.write("name", UsbInterfaceProto.NAME, iface.getName());
|
|
dump.write("class", UsbInterfaceProto.CLASS, iface.getInterfaceClass());
|
|
dump.write("subclass", UsbInterfaceProto.SUBCLASS, iface.getInterfaceSubclass());
|
|
dump.write("protocol", UsbInterfaceProto.PROTOCOL, iface.getInterfaceProtocol());
|
|
|
|
int numEndpoints = iface.getEndpointCount();
|
|
for (int i = 0; i < numEndpoints; i++) {
|
|
writeEndpoint(dump, "endpoints", UsbInterfaceProto.ENDPOINTS, iface.getEndpoint(i));
|
|
}
|
|
dump.end(token);
|
|
}
|
|
|
|
private static void writeEndpoint(@NonNull DualDumpOutputStream dump, @NonNull String idName,
|
|
long id, @NonNull UsbEndpoint endpoint) {
|
|
long token = dump.start(idName, id);
|
|
|
|
dump.write("endpoint_number", UsbEndPointProto.ENDPOINT_NUMBER,
|
|
endpoint.getEndpointNumber());
|
|
dump.write("direction", UsbEndPointProto.DIRECTION, endpoint.getDirection());
|
|
dump.write("address", UsbEndPointProto.ADDRESS, endpoint.getAddress());
|
|
dump.write("type", UsbEndPointProto.TYPE, endpoint.getType());
|
|
dump.write("attributes", UsbEndPointProto.ATTRIBUTES,
|
|
endpoint.getAttributes());
|
|
dump.write("max_packet_size", UsbEndPointProto.MAX_PACKET_SIZE,
|
|
endpoint.getMaxPacketSize());
|
|
dump.write("interval", UsbEndPointProto.INTERVAL, endpoint.getInterval());
|
|
|
|
dump.end(token);
|
|
}
|
|
|
|
public static void writePort(@NonNull DualDumpOutputStream dump, @NonNull String idName,
|
|
long id, @NonNull UsbPort port) {
|
|
long token = dump.start(idName, id);
|
|
|
|
dump.write("id", UsbPortProto.ID, port.getId());
|
|
|
|
int mode = port.getSupportedModes();
|
|
if (dump.isProto()) {
|
|
if (mode == MODE_NONE) {
|
|
dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES, MODE_NONE);
|
|
} else {
|
|
if ((mode & MODE_DUAL) == MODE_DUAL) {
|
|
dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES, MODE_DUAL);
|
|
} else {
|
|
if ((mode & MODE_DFP) == MODE_DFP) {
|
|
dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES, MODE_DFP);
|
|
} else if ((mode & MODE_UFP) == MODE_UFP) {
|
|
dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES, MODE_UFP);
|
|
}
|
|
}
|
|
|
|
if ((mode & MODE_AUDIO_ACCESSORY) == MODE_AUDIO_ACCESSORY) {
|
|
dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES,
|
|
MODE_AUDIO_ACCESSORY);
|
|
}
|
|
|
|
if ((mode & MODE_DEBUG_ACCESSORY) == MODE_DEBUG_ACCESSORY) {
|
|
dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES,
|
|
MODE_DEBUG_ACCESSORY);
|
|
}
|
|
}
|
|
} else {
|
|
dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES, UsbPort.modeToString(mode));
|
|
}
|
|
dump.write("supports_compliance_warnings",
|
|
UsbPortProto.SUPPORTS_COMPLIANCE_WARNINGS,
|
|
port.supportsComplianceWarnings());
|
|
if (port.isAltModeSupported(FLAG_ALT_MODE_TYPE_DISPLAYPORT)) {
|
|
dump.write("supported_alt_modes", UsbPortProto.SUPPORTED_ALT_MODES,
|
|
FLAG_ALT_MODE_TYPE_DISPLAYPORT);
|
|
}
|
|
|
|
dump.end(token);
|
|
}
|
|
|
|
private static void writePowerRole(@NonNull DualDumpOutputStream dump, @NonNull String idName,
|
|
long id, int powerRole) {
|
|
if (dump.isProto()) {
|
|
dump.write(idName, id, powerRole);
|
|
} else {
|
|
dump.write(idName, id, UsbPort.powerRoleToString(powerRole));
|
|
}
|
|
}
|
|
|
|
private static void writeDataRole(@NonNull DualDumpOutputStream dump, @NonNull String idName,
|
|
long id, int dataRole) {
|
|
if (dump.isProto()) {
|
|
dump.write(idName, id, dataRole);
|
|
} else {
|
|
dump.write(idName, id, UsbPort.dataRoleToString(dataRole));
|
|
}
|
|
}
|
|
|
|
private static void writeContaminantPresenceStatus(@NonNull DualDumpOutputStream dump,
|
|
@NonNull String idName, long id, int contaminantPresenceStatus) {
|
|
if (dump.isProto()) {
|
|
dump.write(idName, id, contaminantPresenceStatus);
|
|
} else {
|
|
dump.write(idName, id,
|
|
UsbPort.contaminantPresenceStatusToString(contaminantPresenceStatus));
|
|
}
|
|
}
|
|
|
|
public static void writePortStatus(@NonNull DualDumpOutputStream dump, @NonNull String idName,
|
|
long id, @NonNull UsbPortStatus status) {
|
|
long token = dump.start(idName, id);
|
|
|
|
dump.write("connected", UsbPortStatusProto.CONNECTED, status.isConnected());
|
|
|
|
if (dump.isProto()) {
|
|
dump.write("current_mode", UsbPortStatusProto.CURRENT_MODE, status.getCurrentMode());
|
|
} else {
|
|
dump.write("current_mode", UsbPortStatusProto.CURRENT_MODE,
|
|
UsbPort.modeToString(status.getCurrentMode()));
|
|
}
|
|
|
|
writePowerRole(dump, "power_role", UsbPortStatusProto.POWER_ROLE,
|
|
status.getCurrentPowerRole());
|
|
writeDataRole(dump, "data_role", UsbPortStatusProto.DATA_ROLE, status.getCurrentDataRole());
|
|
|
|
int undumpedCombinations = status.getSupportedRoleCombinations();
|
|
while (undumpedCombinations != 0) {
|
|
int index = Integer.numberOfTrailingZeros(undumpedCombinations);
|
|
undumpedCombinations &= ~(1 << index);
|
|
|
|
int powerRole = (index / Constants.PortDataRole.NUM_DATA_ROLES
|
|
+ Constants.PortPowerRole.NONE);
|
|
int dataRole = index % Constants.PortDataRole.NUM_DATA_ROLES;
|
|
|
|
long roleCombinationToken = dump.start("role_combinations",
|
|
UsbPortStatusProto.ROLE_COMBINATIONS);
|
|
writePowerRole(dump, "power_role", UsbPortStatusRoleCombinationProto.POWER_ROLE,
|
|
powerRole);
|
|
writeDataRole(dump, "data_role", UsbPortStatusRoleCombinationProto.DATA_ROLE,
|
|
dataRole);
|
|
dump.end(roleCombinationToken);
|
|
}
|
|
|
|
writeContaminantPresenceStatus(dump, "contaminant_presence_status",
|
|
UsbPortStatusProto.CONTAMINANT_PRESENCE_STATUS,
|
|
status.getContaminantDetectionStatus());
|
|
dump.write("usb_data_status", UsbPortStatusProto.USB_DATA_STATUS,
|
|
UsbPort.usbDataStatusToString(status.getUsbDataStatus()));
|
|
dump.write("is_power_transfer_limited", UsbPortStatusProto.IS_POWER_TRANSFER_LIMITED,
|
|
status.isPowerTransferLimited());
|
|
dump.write("usb_power_brick_status", UsbPortStatusProto.USB_POWER_BRICK_STATUS,
|
|
UsbPort.powerBrickConnectionStatusToString(status.getPowerBrickConnectionStatus()));
|
|
dump.write("compliance_warning_status", UsbPortStatusProto.COMPLIANCE_WARNINGS_STRING,
|
|
UsbPort.complianceWarningsToString(status.getComplianceWarnings()));
|
|
DisplayPortAltModeInfo displayPortAltModeInfo = status.getDisplayPortAltModeInfo();
|
|
if (displayPortAltModeInfo != null) {
|
|
dump.write("displayport_alt_mode_status",
|
|
UsbPortStatusProto.DISPLAYPORT_ALT_MODE_STATUS,
|
|
status.getDisplayPortAltModeInfo().toString());
|
|
}
|
|
dump.end(token);
|
|
}
|
|
}
|