scottk/OpenCellular
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/OpenCellular.git synced 2025-12-30 02:20:48 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
044cc724967fbb424dd4f686a67abce5a67cfdec
OpenCellular/util/genvif.c
Sam Hurst 9b922a6317 Update genvif to create Rev 1.22 Vendor Info Files 
Update genvif so that it can create Rev 1.22 Vendor Info Files. Also
format the VIF so that it matches VIFs generated with the USB VIF
generator.

BUG=b:69972352
BRANCH=None
TEST=`make -j buildall`
Used generated VIF for nasher on GRL Test Equipment
Signed-off-by: Sam Hurst <shurst@chromium.org>

Change-Id: I35bc940c0c65c89be9a40ff9228e51123f136e7b
Reviewed-on: https://chromium-review.googlesource.com/801874
Commit-Ready: Sam Hurst <shurst@google.com>
Tested-by: Sam Hurst <shurst@google.com>
Reviewed-by: Shawn N <shawnn@chromium.org>
2017-12-06 20:24:12 -08:00

696 lines
15 KiB
C
Raw Blame History

/* Copyright 2017 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#define _GNU_SOURCE /* for asprintf */
#include <errno.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <getopt.h>
#include <dirent.h>
#include <limits.h>
#include "config.h"
#include "usb_pd.h"
#include "usb_pd_tcpm.h"
#include "charge_manager.h"
#include "system.h"
#define PD_REV_2_0 1
#define PD_REV_3_0 2
#define GENVIF_TITLE "EC GENVIF, Version 1.1"
#define VIF_SPEC "Revision 1.22, Version 1.0"
#define VENDOR_NAME "Google"
#define PD_SPEC_REV PD_REV_2_0
enum tab {INTRO = 0, GENERAL, USB, SOURCE, SINK, ROLE, SOP1, SOP2};
enum dtype {SNK = 0, SRC = 3, DRP = 4};
const uint32_t vdo_idh __attribute__((weak)) = 0;
const uint32_t *src_pdo;
uint32_t src_pdo_cnt;
char *yes_no(int val)
{
return val ? "YES" : "NO";
}
enum system_image_copy_t system_get_image_copy(void)
{
return SYSTEM_IMAGE_RW;
}
static void write_title(FILE *vif)
{
fprintf(vif, ";\r\n");
fprintf(vif, "; %s \r\n", GENVIF_TITLE);
fprintf(vif, ";\r\n");
}
static void write_tab(FILE *vif, enum tab t)
{
if (!vif)
return;
fprintf(vif, "\r\n%s\r\n",
";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");
switch (t) {
case INTRO:
fprintf(vif, "; Intro tab\r\n");
break;
case GENERAL:
fprintf(vif, "; General PD Settings tab\r\n");
break;
case USB:
fprintf(vif, "; USB Type-C tab\r\n");
break;
case SOURCE:
fprintf(vif, "; Source tab\r\n");
break;
case SINK:
fprintf(vif, "; Sink tab\r\n");
break;
case ROLE:
fprintf(vif, "; Dual Role tab\r\n");
break;
case SOP1:
fprintf(vif, "; SOP Discovery - Part One tab\r\n");
break;
case SOP2:
fprintf(vif, "; SOP Discovery - Part Two tab\r\n");
break;
}
fprintf(vif, "%s\r\n",
";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");
}
static void init_src_pdos(void)
{
#ifdef CONFIG_USB_PD_DYNAMIC_SRC_CAP
src_pdo_cnt = charge_manager_get_source_pdo(&src_pdo, 0);
#else
src_pdo_cnt = pd_src_pdo_cnt;
src_pdo = pd_src_pdo;
#endif
}
static int is_src(void)
{
return src_pdo_cnt;
}
static int is_snk(void)
{
#ifdef CONFIG_USB_PD_DUAL_ROLE
return pd_snk_pdo_cnt;
#else
return 0;
#endif
}
static int is_extpwr(void)
{
if (is_src())
return !!(src_pdo[0] & PDO_FIXED_EXTERNAL);
else
return 0;
}
static int is_drp(void)
{
if (is_src())
return !!(src_pdo[0] & PDO_FIXED_DUAL_ROLE);
else
return 0;
}
#ifdef CONFIG_USB_PD_DUAL_ROLE
static char *giveback(void)
{
#ifdef CONFIG_USB_PD_GIVE_BACK
return "YES";
#else
return "NO";
#endif
}
#endif
static char *is_comms_cap(void)
{
if (is_src())
return yes_no(src_pdo[0] & PDO_FIXED_COMM_CAP);
else
return "NO";
}
static char *dr_swap_to_ufp_supported(void)
{
if (src_pdo[0] & PDO_FIXED_DATA_SWAP)
return yes_no(pd_check_data_swap(0, PD_ROLE_DFP));
return "NO";
}
static char *dr_swap_to_dfp_supported(void)
{
if (src_pdo[0] & PDO_FIXED_DATA_SWAP)
return yes_no(pd_check_data_swap(0, PD_ROLE_UFP));
return "NO";
}
static char *vconn_swap(void)
{
#ifdef CONFIG_USBC_VCONN_SWAP
return "YES";
#else
return "NO";
#endif
}
static char *try_src(void)
{
#ifdef CONFIG_USB_PD_TRY_SRC
return "YES";
#else
return "NO";
#endif
}
static char *can_act_as_host(void)
{
#ifdef CONFIG_VIF_TYPE_C_CAN_ACT_AS_HOST
return "YES";
#else
return "NO";
#endif
}
static char *can_act_as_device(void)
{
#ifdef CONFIG_USB
return "YES";
#else
return "NO";
#endif
}
static char *captive_cable(void)
{
#ifdef CONFIG_VIF_CAPTIVE_CABLE
return "YES";
#else
return "NO";
#endif
}
static char *sources_vconn(void)
{
#ifdef CONFIG_USBC_VCONN
return "YES";
#else
return "NO";
#endif
}
static char *battery_powered(void)
{
#ifdef CONFIG_BATTERY
return "YES";
#else
return "NO";
#endif
}
static uint32_t product_type(void)
{
return PD_IDH_PTYPE(vdo_idh);
}
static uint32_t pid_sop(void)
{
#ifdef CONFIG_USB_PID
return CONFIG_USB_PID;
#else
return 0;
#endif
}
static uint32_t rp_value(void)
{
#ifdef CONFIG_USB_PD_MAX_SINGLE_SOURCE_CURRENT
return CONFIG_USB_PD_MAX_SINGLE_SOURCE_CURRENT;
#else
return 0;
#endif
}
static char *attempts_discov_sop(enum dtype type)
{
#ifdef CONFIG_USB_PD_SIMPLE_DFP
if (type == SRC)
return "NO";
else
return "YES";
#else
return "YES";
#endif
}
static uint32_t bcddevice_sop(void)
{
#ifdef CONFIG_USB_BCD_DEV
return CONFIG_USB_BCD_DEV;
#else
return 0;
#endif
}
/* Application exits on failure */
static void append(char **buf, const char *fmt, ...)
{
va_list ap1, ap2;
int n;
static int offset;
va_start(ap1, fmt);
va_copy(ap2, ap1);
n = vsnprintf(NULL, 0, fmt, ap1) + 1;
if (*buf == NULL)
offset = 0;
*buf = (char *)realloc(*buf, offset + n);
if (*buf) {
vsnprintf(*buf + offset, n, fmt, ap2);
} else {
fprintf(stderr, "ERROR: Out of memory.\n");
exit(EXIT_FAILURE);
}
/* Overwrite NULL terminator the next time through. */
offset += (n-1);
va_end(ap1);
va_end(ap2);
}
static int32_t write_pdo_to_buf(char **buf, uint32_t pdo,
enum dtype type, uint32_t pnum)
{
int32_t power;
if ((pdo & PDO_TYPE_MASK) == PDO_TYPE_FIXED) {
uint32_t current = pdo & 0x3ff;
uint32_t voltage = (pdo >> 10) & 0x3ff;
power = ((current * 10) * (voltage * 50)) / 1000;
append(buf, "\t%s_PDO_Supply_Type%d: 0\r\n",
(type == SRC) ? "Src" : "Snk", pnum);
if (type == SRC)
append(buf, "\tSrc_PDO_Peak_Current%d: 0\r\n", pnum);
append(buf, "\t%s_PDO_Voltage%d: %d\r\n",
(type == SRC) ? "Src" : "Snk", pnum, voltage);
if (type == SRC)
append(buf, "\tSrc_PDO_Max_Current%d: %d\r\n", pnum,
current);
else
append(buf, "\tSnk_PDO_Op_Current%d: %d\r\n", pnum,
current);
} else if ((pdo & PDO_TYPE_MASK) == PDO_TYPE_BATTERY) {
uint32_t max_voltage = (pdo >> 20) & 0x3ff;
uint32_t min_voltage = (pdo >> 10) & 0x3ff;
power = pdo & 0x3ff;
append(buf, "\t%s_PDO_Supply_Type%d: 1\r\n",
(type == SRC) ? "Src" : "Snk", pnum);
append(buf, "\t%s_PDO_Min_Voltage%d: %d\r\n",
(type == SRC) ? "Src" : "Snk", pnum, min_voltage);
append(buf, "\t%s_PDO_Max_Voltage%d: %d\r\n",
(type == SRC) ? "Src" : "Snk", pnum, max_voltage);
if (type == SRC)
append(buf, "\tSrc_PDO_Max_Power%d: %d\r\n", pnum,
power);
else
append(buf, "\tSnk_PDO_Op_Power%d: %d\r\n", pnum,
power);
} else if ((pdo & PDO_TYPE_MASK) == PDO_TYPE_VARIABLE) {
uint32_t max_voltage = (pdo >> 20) & 0x3ff;
uint32_t min_voltage = (pdo >> 10) & 0x3ff;
uint32_t current = pdo & 0x3ff;
power = ((current * 10) * (max_voltage * 50)) / 1000;
append(buf, "\t%s_PDO_Supply_Type%d: 2\r\n",
(type == SRC) ? "Src" : "Snk", pnum);
if (type == SRC)
append(buf, "\tSrc_PDO_Peak_Current%d: 0\r\n", pnum);
append(buf, "\t%s_PDO_Min_Voltage%d: %d\r\n",
(type == SRC) ? "Src" : "Snk", pnum, min_voltage);
append(buf, "\t%s_PDO_Max_Voltage%d: %d\r\n",
(type == SRC) ? "Src" : "Snk", pnum, max_voltage);
if (type == SRC)
append(buf, "\tSrc_PDO_Max_Current%d: %d\r\n", pnum,
current);
else
append(buf, "\tSnk_PDO_Op_Current%d: %d\r\n", pnum,
current);
} else {
fprintf(stderr, "ERROR: Invalid PDO_TYPE %d.\n", pdo);
return -1;
}
append(buf, "\r\n");
return power;
}
/**
* Carriage and line feed, '\r\n', is needed because the file is processed
* on a Windows machine.
*/
static int gen_vif(const char *name, const char *board,
const char *vif_producer)
{
FILE *vif;
enum dtype type;
char *type_name;
if (is_drp()) {
type = DRP;
type_name = "DRP";
} else if (is_src() && is_snk()) {
/* No DRP with SRC and SNK PDOs detected. So ignore. */
/* ie. Twinki or Plankton */
return 0;
} else if (is_src()) {
type = SRC;
type_name = "SRC";
} else if (is_snk()) {
type = SNK;
type_name = "SNK";
} else {
return 1;
}
/* Create VIF */
vif = fopen(name, "w+");
if (vif == NULL)
return 1;
/* Write VIF Title */
write_title(vif);
/* Write Intro Tab comment */
write_tab(vif, INTRO);
/* Write VIF Header */
fprintf(vif, "$VIF_Specification: \"%s\"\r\n", VIF_SPEC);
fprintf(vif, "$VIF_Producer: \"%s\"\r\n", vif_producer);
fprintf(vif, "UUT_Device_Type: %d ; %s\r\n", type, type_name);
fprintf(vif, "$Vendor_Name: \"%s\"\r\n", VENDOR_NAME);
fprintf(vif, "$Product_Name: \"%s\"\r\n", board);
/* Write General PD Settings Tab comment */
write_tab(vif, GENERAL);
fprintf(vif, "PD_Specification_Revision: %d\r\n", PD_SPEC_REV);
fprintf(vif, "SOP_Capable: YES\r\n");
fprintf(vif, "SOP_P_Capable: NO\r\n");
fprintf(vif, "SOP_PP_Capable: NO\r\n");
fprintf(vif, "SOP_P_Debug_Capable: NO\r\n");
fprintf(vif, "SOP_PP_Debug_Capable: NO\r\n");
fprintf(vif, "USB_Comms_Capable: %s\r\n", is_comms_cap());
fprintf(vif, "DR_Swap_To_DFP_Supported: %s\r\n",
dr_swap_to_dfp_supported());
fprintf(vif, "DR_Swap_To_UFP_Supported: %s\r\n",
dr_swap_to_ufp_supported());
fprintf(vif, "Unconstrained_Powered: %s\r\n", yes_no(is_extpwr()));
fprintf(vif, "VCONN_Swap_To_On_Supported: %s\r\n", vconn_swap());
fprintf(vif, "VCONN_Swap_To_Off_Supported: %s\r\n", vconn_swap());
fprintf(vif, "Responds_To_Discov_SOP: YES\r\n");
fprintf(vif, "Attempts_Discov_SOP: %s\r\n", attempts_discov_sop(type));
/* Write USB Type-C Tab comment */
write_tab(vif, USB);
/* set Type_C_State_Machine */
{
int typec;
switch (type) {
case DRP:
typec = 2;
break;
case SNK:
typec = 1;
break;
default:
typec = 0;
}
fprintf(vif,
"Type_C_State_Machine: %d ; %s\r\n", typec, type_name);
}
fprintf(vif, "Type_C_Implements_Try_SRC: %s\r\n", try_src());
fprintf(vif, "Type_C_Implements_Try_SNK: NO\r\n");
fprintf(vif, "Rp_Value: %d\r\n", rp_value());
/* None of the current devices send SOP' / SOP", so NO.*/
fprintf(vif, "Type_C_Is_VCONN_Powered_Accessory: NO\r\n");
fprintf(vif, "Type_C_Supports_VCONN_Powered_Accessory: NO\r\n");
fprintf(vif, "Type_C_Is_Debug_Target_SRC: YES\r\n");
fprintf(vif, "Type_C_Is_Debug_Target_SNK: YES\r\n");
fprintf(vif, "Type_C_Can_Act_As_Host: %s\r\n", can_act_as_host());
/* Supports USB 3.1 when communicating as a host */
fprintf(vif, "Type_C_Host_Speed: 4\r\n");
fprintf(vif, "Type_C_Can_Act_As_Device: %s\r\n", can_act_as_device());
fprintf(vif, "Type_C_Device_Speed: 4\r\n");
fprintf(vif, "Type_C_Is_Alt_Mode_Controller: YES\r\n");
fprintf(vif, "Type_C_Is_Alt_Mode_Device: NO\r\n");
fprintf(vif, "Type_C_Power_Source: 2\r\n");
fprintf(vif, "Type_C_BC_1_2_Support: 1\r\n");
fprintf(vif, "Type_C_Battery_Powered: %s\r\n", battery_powered());
fprintf(vif, "Type_C_Port_On_Hub: NO\r\n");
fprintf(vif, "Type_C_Supports_Audio_Accessory: NO\r\n");
fprintf(vif, "Captive_Cable: %s\r\n", captive_cable());
fprintf(vif, "Type_C_Source_Vconn: %s\r\n", sources_vconn());
/* Write Source Fields */
if (type == DRP || type == SRC) {
uint32_t max_power = 0;
char *buf = NULL;
int i;
int32_t pwr;
/* Write Source PDOs */
for (i = 0; i < src_pdo_cnt; i++) {
pwr = write_pdo_to_buf(&buf, src_pdo[i], SRC, i+1);
if (pwr < 0) {
fprintf(stderr, "ERROR: Out of memory.\n");
return 1;
}
if (pwr > max_power)
max_power = pwr;
}
/* Write Source Tab comment */
write_tab(vif, SOURCE);
fprintf(vif, "PD_Power_as_Source: %d\r\n", max_power);
fprintf(vif, "USB_Suspend_May_Be_Cleared: YES\r\n");
fprintf(vif, "Sends_Pings: NO\r\n");
fprintf(vif, "Num_Src_PDOs: %d\r\n", src_pdo_cnt);
fprintf(vif, "\r\n%s\r\n", buf);
free(buf);
}
#ifdef CONFIG_USB_PD_DUAL_ROLE
if (type == DRP || type == SNK) {
uint32_t max_power = 0;
char *buf = NULL;
int32_t pwr;
int i;
/* Write Sink PDOs */
for (i = 0; i < pd_snk_pdo_cnt; i++) {
pwr = write_pdo_to_buf(&buf, pd_snk_pdo[i], SNK, i+1);
if (pwr < 0) {
fprintf(stderr, "ERROR: Out of memory.\n");
return 1;
}
if (pwr > max_power)
max_power = pwr;
}
/* Write Sink Tab comment */
write_tab(vif, SINK);
fprintf(vif, "PD_Power_as_Sink: %d\r\n", max_power);
fprintf(vif, "USB_Suspend_May_Be_Cleared: NO\r\n");
fprintf(vif, "GiveBack_May_Be_Set: %s\r\n", giveback());
fprintf(vif, "Higher_Capability_Set: NO\r\n");
fprintf(vif, "Num_Snk_PDOs: %d\r\n", pd_snk_pdo_cnt);
fprintf(vif, "\r\n%s\r\n", buf);
free(buf);
}
/* Write DRP Fields */
if (type == DRP) {
/* Write Dual Role Tab comment */
write_tab(vif, ROLE);
fprintf(vif, "Accepts_PR_Swap_As_Src: YES\r\n");
fprintf(vif, "Accepts_PR_Swap_As_Snk: YES\r\n");
fprintf(vif, "Requests_PR_Swap_As_Src: YES\r\n");
fprintf(vif, "Requests_PR_Swap_As_Snk: YES\r\n");
}
#endif
/* Write SOP Discovery -Part One Tab comment */
write_tab(vif, SOP1);
/* SOP Discovery Fields */
fprintf(vif, "Structured_VDM_Version_SOP: 0\r\n");
fprintf(vif, "XID_SOP: 0\r\n");
fprintf(vif, "Data_Capable_as_USB_Host_SOP: %s\r\n",
can_act_as_host());
fprintf(vif, "Data_Capable_as_USB_Device_SOP: %s\r\n",
can_act_as_device());
fprintf(vif, "Product_Type_SOP: %d\r\n", product_type());
fprintf(vif, "Modal_Operation_Supported_SOP: YES\r\n");
fprintf(vif, "USB_VID_SOP: 0x%04x\r\n", USB_VID_GOOGLE);
fprintf(vif, "PID_SOP: 0x%04x\r\n", pid_sop());
fprintf(vif, "bcdDevice_SOP: 0x%04x\r\n", bcddevice_sop());
{
int svid_num;
/* Write SOP Discovery -Part One Tab comment */
write_tab(vif, SOP2);
#ifdef USB_SID_DISPLAYPORT
svid_num = 2;
#else
svid_num = 1;
#endif
fprintf(vif, "SVID_fixed_SOP: YES\r\n");
fprintf(vif, "Num_SVIDs_min_SOP: %d\r\n", svid_num);
fprintf(vif, "Num_SVIDs_max_SOP: %d\r\n\n", svid_num);
}
fprintf(vif, "\tSVID1_SOP: 0x%04x\r\n", USB_VID_GOOGLE);
fprintf(vif, "\tSVID1_modes_fixed_SOP: YES\r\n");
fprintf(vif, "\tSVID1_num_modes_min_SOP: 1\r\n");
fprintf(vif, "\tSVID1_num_modes_max_SOP: 1\r\n");
fprintf(vif, "\tSVID1_mode1_enter_SOP: YES\r\n\n");
#ifdef USB_SID_DISPLAYPORT
fprintf(vif, "\tSVID2_SOP: 0x%04x\r\n", USB_SID_DISPLAYPORT);
fprintf(vif, "\tSVID2_modes_fixed_SOP: YES\r\n");
fprintf(vif, "\tSVID2_num_modes_min_SOP: 2\r\n");
fprintf(vif, "\tSVID2_num_modes_max_SOP: 2\r\n");
fprintf(vif, "\tSVID2_mode1_enter_SOP: YES\r\n");
fprintf(vif, "\tSVID2_mode2_enter_SOP: YES\r\n");
#endif
fclose(vif);
return 0;
}
int main(int argc, char **argv)
{
int nopt;
int ret;
const char *out = NULL;
const char *board = NULL;
const char *vif_producer;
DIR *vifdir;
char *name;
int name_size;
const char * const short_opt = "hb:o:";
const struct option long_opts[] = {
{ "help", 0, NULL, 'h' },
{ "board", 1, NULL, 'b' },
{ "out", 1, NULL, 'o' },
{ NULL }
};
vif_producer = argv[0];
do {
nopt = getopt_long(argc, argv, short_opt, long_opts, NULL);
switch (nopt) {
case 'h': /* -h or --help */
printf("USAGE: %s -b <board name> -o <out directory>\n",
vif_producer);
return 1;
case 'b': /* -b or --board */
board = optarg;
break;
case 'o': /* -o or --out */
out = optarg;
break;
case -1:
break;
default:
abort();
}
} while (nopt != -1);
if (out == NULL || board == NULL)
return 1;
/* Make sure VIF directory exists */
vifdir = opendir(out);
if (vifdir == NULL) {
fprintf(stderr, "ERROR: %s directory does not exist.\n", out);
return 1;
}
closedir(vifdir);
init_src_pdos();
name_size = asprintf(&name, "%s/%s_vif.txt", out, board);
if (name_size < 0) {
fprintf(stderr, "ERROR: Out of memory.\n");
return 1;
}
ret = gen_vif(name, board, vif_producer);
free(name);
return ret;
}
Reference in New Issue View Git Blame Copy Permalink