Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
mtb-example-pmg1-usbpd-sink-lcd-display/main.c
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
450 lines (384 sloc)
13.6 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/****************************************************************************** | |
* File Name: main.c | |
* | |
* Description: This is the source code for the USB PD Sink with 16x2 LCD Example | |
* for ModusToolbox. | |
* | |
* Related Document: See README.md | |
* | |
* | |
*******************************************************************************/ | |
/******************************************************************************* | |
* Include header files | |
******************************************************************************/ | |
#include "cy_pdl.h" | |
#include "cybsp.h" | |
#include "lcd.h" | |
#include "config.h" | |
#include "cy_pdutils_sw_timer.h" | |
#include "cy_usbpd_common.h" | |
#include "cy_pdstack_common.h" | |
#include "cy_usbpd_typec.h" | |
#include "cy_pdstack_dpm.h" | |
#include "cy_usbpd_vbus_ctrl.h" | |
#include "cy_usbpd_phy.h" | |
#include "instrumentation.h" | |
#include "app.h" | |
#include "pdo.h" | |
#include "psink.h" | |
#include "swap.h" | |
#include "vdm.h" | |
#include "charger_detect.h" | |
#include "mtbcfg_ezpd.h" | |
/******************************************************************************* | |
* Macros | |
******************************************************************************/ | |
/* CY Assert Failure */ | |
#define CY_ASSERT_FAILED (0U) | |
/******************************************************************************* | |
* Global Variables | |
*******************************************************************************/ | |
/* LED blink rate in milliseconds */ | |
static uint16_t gl_LedBlinkRate = LED_TIMER_PERIOD_DETACHED; | |
/* Variable used to store the type of Type-C power source connected */ | |
uint8_t srcType = 0U; | |
/* Enumeration objects for LCD */ | |
lcd_write_state_t lcd_write_state; | |
lcd_print_state_t lcd_print_state; | |
cy_stc_pdutils_sw_timer_t gl_TimerCtx; | |
cy_stc_usbpd_context_t gl_UsbPdPort0Ctx; | |
cy_stc_pdstack_context_t gl_PdStackPort0Ctx; | |
#if PMG1_PD_DUALPORT_ENABLE | |
cy_stc_usbpd_context_t gl_UsbPdPort1Ctx; | |
cy_stc_pdstack_context_t gl_PdStackPort1Ctx; | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
const cy_stc_pdstack_dpm_params_t pdstack_port0_dpm_params = | |
{ | |
.dpmSnkWaitCapPeriod = 400, | |
.dpmRpAudioAcc = CY_PD_RP_TERM_RP_CUR_DEF, | |
.dpmDefCableCap = 300, | |
.muxEnableDelayPeriod = 0, | |
.typeCSnkWaitCapPeriod = 0, | |
.defCur = 90 | |
}; | |
#if PMG1_PD_DUALPORT_ENABLE | |
const cy_stc_pdstack_dpm_params_t pdstack_port1_dpm_params = | |
{ | |
.dpmSnkWaitCapPeriod = 400, | |
.dpmRpAudioAcc = CY_PD_RP_TERM_RP_CUR_DEF, | |
.dpmDefCableCap = 300, | |
.muxEnableDelayPeriod = 0, | |
.typeCSnkWaitCapPeriod = 0, | |
.defCur = 90 | |
}; | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
cy_stc_pdstack_context_t * gl_PdStackContexts[NO_OF_TYPEC_PORTS] = | |
{ | |
&gl_PdStackPort0Ctx, | |
#if PMG1_PD_DUALPORT_ENABLE | |
&gl_PdStackPort1Ctx | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
}; | |
bool mux_ctrl_init(uint8_t port) | |
{ | |
/* No MUXes to be controlled on the PMG1 proto kits. */ | |
CY_UNUSED_PARAMETER(port); | |
return true; | |
} | |
const cy_stc_sysint_t wdt_interrupt_config = | |
{ | |
.intrSrc = (IRQn_Type)srss_interrupt_wdt_IRQn, | |
.intrPriority = 0U, | |
}; | |
const cy_stc_sysint_t usbpd_port0_intr0_config = | |
{ | |
.intrSrc = (IRQn_Type)mtb_usbpd_port0_IRQ, | |
.intrPriority = 0U, | |
}; | |
const cy_stc_sysint_t usbpd_port0_intr1_config = | |
{ | |
.intrSrc = (IRQn_Type)mtb_usbpd_port0_DS_IRQ, | |
.intrPriority = 0U, | |
}; | |
#if PMG1_PD_DUALPORT_ENABLE | |
const cy_stc_sysint_t usbpd_port1_intr0_config = | |
{ | |
.intrSrc = (IRQn_Type)mtb_usbpd_port1_IRQ, | |
.intrPriority = 0U, | |
}; | |
const cy_stc_sysint_t usbpd_port1_intr1_config = | |
{ | |
.intrSrc = (IRQn_Type)mtb_usbpd_port1_DS_IRQ, | |
.intrPriority = 0U, | |
}; | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
cy_stc_pdstack_context_t *get_pdstack_context(uint8_t portIdx) | |
{ | |
return (gl_PdStackContexts[portIdx]); | |
} | |
/* Solution PD event handler */ | |
void sln_pd_event_handler(cy_stc_pdstack_context_t* ctx, cy_en_pdstack_app_evt_t evt, const void *data) | |
{ | |
(void)ctx; | |
if(evt == APP_EVT_HANDLE_EXTENDED_MSG) | |
{ | |
cy_stc_pd_packet_extd_t * ext_mes = (cy_stc_pd_packet_extd_t * )data; | |
if ((ext_mes->msg != CY_PDSTACK_EXTD_MSG_SECURITY_RESP) && (ext_mes->msg != CY_PDSTACK_EXTD_MSG_FW_UPDATE_RESP)) | |
{ | |
/* Send Not supported message */ | |
Cy_PdStack_Dpm_SendPdCommand(ctx, CY_PDSTACK_DPM_CMD_SEND_NOT_SUPPORTED, NULL, true, NULL); | |
} | |
} | |
} | |
void instrumentation_cb(uint8_t port, inst_evt_t evt) | |
{ | |
uint8_t evt_offset = APP_TOTAL_EVENTS; | |
evt += evt_offset; | |
sln_pd_event_handler(&gl_PdStackPort0Ctx, (cy_en_pdstack_app_evt_t)evt, NULL); | |
} | |
static void wdt_interrupt_handler(void) | |
{ | |
/* Clear WDT pending interrupt */ | |
Cy_WDT_ClearInterrupt(); | |
#if (CY_PDUTILS_TIMER_TICKLESS_ENABLE == 0) | |
/* Load the timer match register. */ | |
Cy_WDT_SetMatch((Cy_WDT_GetCount() + gl_TimerCtx.multiplier)); | |
#endif /* (TIMER_TICKLESS_ENABLE == 0) */ | |
/* Invoke the timer handler. */ | |
Cy_PdUtils_SwTimer_InterruptHandler (&(gl_TimerCtx)); | |
} | |
static void cy_usbpd0_intr0_handler(void) | |
{ | |
Cy_USBPD_Intr0Handler(&gl_UsbPdPort0Ctx); | |
} | |
static void cy_usbpd0_intr1_handler(void) | |
{ | |
Cy_USBPD_Intr1Handler(&gl_UsbPdPort0Ctx); | |
} | |
#if PMG1_PD_DUALPORT_ENABLE | |
static void cy_usbpd1_intr0_handler(void) | |
{ | |
Cy_USBPD_Intr0Handler(&gl_UsbPdPort1Ctx); | |
} | |
static void cy_usbpd1_intr1_handler(void) | |
{ | |
Cy_USBPD_Intr1Handler(&gl_UsbPdPort1Ctx); | |
} | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
#if APP_FW_LED_ENABLE | |
void led_timer_cb ( | |
cy_timer_id_t id, /**< Timer ID for which callback is being generated. */ | |
void *callbackContext) /**< Timer module Context. */ | |
{ | |
cy_stc_pdstack_context_t *stack_ctx = (cy_stc_pdstack_context_t *)callbackContext; | |
#if BATTERY_CHARGING_ENABLE | |
const chgdet_status_t *chgdet_stat; | |
#endif /* #if BATTERY_CHARGING_ENABLE */ | |
/* Toggle the User LED and re-start timer to schedule the next toggle event. */ | |
Cy_GPIO_Inv(CYBSP_USER_LED_PORT, CYBSP_USER_LED_PIN); | |
/* Calculate the desired LED blink rate based on the correct Type-C connection state. */ | |
if (stack_ctx->dpmConfig.attach) | |
{ | |
if (stack_ctx->dpmConfig.contractExist) | |
{ | |
gl_LedBlinkRate = LED_TIMER_PERIOD_PD_SRC; | |
srcType = PD_POWER_SOURCE; | |
} | |
else | |
{ | |
#if BATTERY_CHARGING_ENABLE | |
chgdet_stat = chgdet_get_status(stack_ctx); | |
if (chgdet_stat->chgdet_fsm_state == CHGDET_FSM_SINK_DCP_CONNECTED) | |
{ | |
gl_LedBlinkRate = LED_TIMER_PERIOD_DCP_SRC; | |
srcType = DCP_SOURCE; | |
} | |
else if (chgdet_stat->chgdet_fsm_state == CHGDET_FSM_SINK_CDP_CONNECTED) | |
{ | |
gl_LedBlinkRate = LED_TIMER_PERIOD_CDP_SRC; | |
srcType = CDP_SOURCE; | |
} | |
else | |
#endif /* BATTERY_CHARGING_ENABLE */ | |
{ | |
gl_LedBlinkRate = LED_TIMER_PERIOD_TYPEC_SRC; | |
srcType = SDP_SOURCE; | |
} | |
} | |
} | |
else | |
{ | |
gl_LedBlinkRate = LED_TIMER_PERIOD_DETACHED; | |
srcType = TYPE_C_DISCONNECT; | |
} | |
Cy_PdUtils_SwTimer_Start (&gl_TimerCtx, callbackContext, id, gl_LedBlinkRate, led_timer_cb); | |
} | |
#endif /* APP_FW_LED_ENABLE */ | |
cy_stc_pd_dpm_config_t* get_dpm_connect_stat(void) | |
{ | |
return &(gl_PdStackPort0Ctx.dpmConfig); | |
} | |
#if PMG1_PD_DUALPORT_ENABLE | |
cy_stc_pd_dpm_config_t* get_dpm_port1_connect_stat() | |
{ | |
return &(gl_PdStackPort1Ctx.dpmConfig); | |
} | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
/* | |
* Application callback functions for the DPM. Since this application | |
* uses the functions provided by the stack, loading the stack defaults. | |
*/ | |
const cy_stc_pdstack_app_cbk_t app_callback = | |
{ | |
app_event_handler, | |
vconn_enable, | |
vconn_disable, | |
vconn_is_present, | |
vbus_is_present, | |
vbus_discharge_on, | |
vbus_discharge_off, | |
psnk_set_voltage, | |
psnk_set_current, | |
psnk_enable, | |
psnk_disable, | |
eval_src_cap, | |
eval_dr_swap, | |
eval_pr_swap, | |
eval_vconn_swap, | |
eval_vdm, | |
vbus_get_value, | |
}; | |
cy_stc_pdstack_app_cbk_t* app_get_callback_ptr(cy_stc_pdstack_context_t * context) | |
{ | |
(void)context; | |
/* Solution callback pointer is same for all ports */ | |
return ((cy_stc_pdstack_app_cbk_t *)(&app_callback)); | |
} | |
int main(void) | |
{ | |
cy_rslt_t result; | |
cy_stc_pdutils_timer_config_t timerConfig; | |
/* Initialize the device and board peripherals */ | |
result = cybsp_init() ; | |
if (result != CY_RSLT_SUCCESS) | |
{ | |
CY_ASSERT(CY_ASSERT_FAILED); | |
} | |
/* Initialize the TCPWM component in PWM mode */ | |
result = Cy_TCPWM_PWM_Init(CYBSP_PWM_HW, CYBSP_PWM_NUM, &CYBSP_PWM_config); | |
if (result != CY_TCPWM_SUCCESS) | |
{ | |
CY_ASSERT(CY_ASSERT_FAILED); | |
} | |
/* Set PWM compare value */ | |
Cy_TCPWM_PWM_SetCompare0(CYBSP_PWM_HW, CYBSP_PWM_NUM, PWM_COMPARE); | |
/* Enable the TCPWM as PWM */ | |
Cy_TCPWM_PWM_Enable(CYBSP_PWM_HW, CYBSP_PWM_NUM); | |
/* Start the PWM */ | |
Cy_TCPWM_TriggerReloadOrIndex(CYBSP_PWM_HW, CYBSP_PWM_MASK); | |
/* | |
* Register the interrupt handler for the watchdog timer. This timer is used to | |
* implement the soft timers required by the USB-PD Stack. | |
*/ | |
Cy_SysInt_Init(&wdt_interrupt_config, &wdt_interrupt_handler); | |
NVIC_EnableIRQ(wdt_interrupt_config.intrSrc); | |
timerConfig.sys_clk_freq = Cy_SysClk_ClkSysGetFrequency(); | |
timerConfig.hw_timer_ctx = NULL; | |
/* Initialize the soft timer module. */ | |
Cy_PdUtils_SwTimer_Init(&gl_TimerCtx, &timerConfig); | |
/* Enable global interrupts */ | |
__enable_irq(); | |
/* Initialize the instrumentation related data structures. */ | |
instrumentation_init(); | |
/* Register callback function to be executed when instrumentation fault occurs. */ | |
instrumentation_register_cb((instrumentation_cb_t)instrumentation_cb); | |
/* Configure and enable the USBPD interrupts */ | |
Cy_SysInt_Init(&usbpd_port0_intr0_config, &cy_usbpd0_intr0_handler); | |
NVIC_EnableIRQ(usbpd_port0_intr0_config.intrSrc); | |
Cy_SysInt_Init(&usbpd_port0_intr1_config, &cy_usbpd0_intr1_handler); | |
NVIC_EnableIRQ(usbpd_port0_intr1_config.intrSrc); | |
#if PMG1_PD_DUALPORT_ENABLE | |
/* Configure and enable the USBPD interrupts for Port #1. */ | |
Cy_SysInt_Init(&usbpd_port1_intr0_config, &cy_usbpd1_intr0_handler); | |
NVIC_EnableIRQ(usbpd_port1_intr0_config.intrSrc); | |
Cy_SysInt_Init(&usbpd_port1_intr1_config, &cy_usbpd1_intr1_handler); | |
NVIC_EnableIRQ(usbpd_port1_intr1_config.intrSrc); | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
/* Initialize the USBPD driver */ | |
#if defined(CY_DEVICE_SERIES_PMG1S2) | |
Cy_USBPD_Init(&gl_UsbPdPort0Ctx, 0, mtb_usbpd_port0_HW, NULL, | |
(cy_stc_usbpd_config_t *)&mtb_usbpd_port0_config, get_dpm_connect_stat); | |
#else | |
Cy_USBPD_Init(&gl_UsbPdPort0Ctx, 0, mtb_usbpd_port0_HW, mtb_usbpd_port0_HW_TRIM, | |
(cy_stc_usbpd_config_t *)&mtb_usbpd_port0_config, get_dpm_connect_stat); | |
#if PMG1_PD_DUALPORT_ENABLE | |
Cy_USBPD_Init(&gl_UsbPdPort1Ctx, 1, mtb_usbpd_port1_HW, mtb_usbpd_port1_HW_TRIM, | |
(cy_stc_usbpd_config_t *)&mtb_usbpd_port1_config, get_dpm_port1_connect_stat); | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
#endif | |
/* Initialize the Device Policy Manager. */ | |
Cy_PdStack_Dpm_Init(&gl_PdStackPort0Ctx, | |
&gl_UsbPdPort0Ctx, | |
&mtb_usbpd_port0_pdstack_config, | |
app_get_callback_ptr(&gl_PdStackPort0Ctx), | |
&pdstack_port0_dpm_params, | |
&gl_TimerCtx); | |
#if PMG1_PD_DUALPORT_ENABLE | |
Cy_PdStack_Dpm_Init(&gl_PdStackPort1Ctx, | |
&gl_UsbPdPort1Ctx, | |
&mtb_usbpd_port1_pdstack_config, | |
app_get_callback_ptr(&gl_PdStackPort1Ctx), | |
&pdstack_port1_dpm_params, | |
&gl_TimerCtx); | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
/* Perform application level initialization. */ | |
app_init(&gl_PdStackPort0Ctx); | |
#if PMG1_PD_DUALPORT_ENABLE | |
app_init(&gl_PdStackPort1Ctx); | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
/* Initialize the fault configuration values */ | |
fault_handler_init_vars(&gl_PdStackPort0Ctx); | |
#if PMG1_PD_DUALPORT_ENABLE | |
fault_handler_init_vars(&gl_PdStackPort1Ctx); | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
/* Start any timers or tasks associated with application instrumentation. */ | |
instrumentation_start(); | |
/* Start the device policy manager operation. This will initialize the USB-PD block and enable connect detection. */ | |
Cy_PdStack_Dpm_Start(&gl_PdStackPort0Ctx); | |
#if PMG1_PD_DUALPORT_ENABLE | |
Cy_PdStack_Dpm_Start(&gl_PdStackPort1Ctx); | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
#if APP_FW_LED_ENABLE | |
/* Start a timer that will blink the FW ACTIVE LED. */ | |
Cy_PdUtils_SwTimer_Start (&gl_TimerCtx, (void *)&gl_PdStackPort0Ctx, (cy_timer_id_t)LED_TIMER_ID, | |
gl_LedBlinkRate, led_timer_cb); | |
#endif /* APP_FW_LED_ENABLE */ | |
/* Initialize LCD */ | |
lcd_init(); | |
/* Setting the initial states */ | |
lcd_print_state = FIRST_ROW; | |
lcd_write_state = LCD_CMD; | |
/* | |
* After the initialization is complete, keep processing the USB-PD device policy manager task in a loop. | |
* Since this application does not have any other function, the PMG1 device can be placed in "deep sleep" | |
* mode for power saving whenever the PD stack and drivers are idle. | |
*/ | |
for (;;) | |
{ | |
/* Handle the device policy tasks for each PD port. */ | |
Cy_PdStack_Dpm_Task(&gl_PdStackPort0Ctx); | |
#if PMG1_PD_DUALPORT_ENABLE | |
Cy_PdStack_Dpm_Task(&gl_PdStackPort1Ctx); | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
/* Perform any application level tasks. */ | |
app_task(&gl_PdStackPort0Ctx); | |
#if PMG1_PD_DUALPORT_ENABLE | |
app_task(&gl_PdStackPort1Ctx); | |
#endif /* PMG1_PD_DUALPORT_ENABLE */ | |
/* Perform tasks associated with instrumentation. */ | |
instrumentation_task(); | |
/* Print PD source details */ | |
lcd_print_pd_details(); | |
} | |
} | |
/* [] END OF FILE */ |