ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Added missing astyle corrections for usb/device/targets/*

pull/10166/head
Cruz Monrreal II 2019-03-19 17:10:32 -05:00
parent da208393c4
commit a1c047aba4
10 changed files with 132 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
usb/device/targets/TARGET_Freescale/USBPhyHw.h
View File

@ -36,7 +36,7 @@ public:
virtual void sof_disable();
virtual void set_address(uint8_t address);
virtual void remote_wakeup();
virtual const usb_ep_table_t* endpoint_table();
virtual const usb_ep_table_t *endpoint_table();
virtual uint32_t ep0_set_max_packet(uint32_t max_packet);
virtual void ep0_setup_read_result(uint8_t *buffer, uint32_t size);

63
usb/device/targets/TARGET_Freescale/USBPhy_Kinetis.cpp
View File

@ -83,7 +83,7 @@ typedef enum {
// * as there are ODD and EVEN buffer -> 8*2 bdt
MBED_ALIGN(512) BDT bdt[NUMBER_OF_PHYSICAL_ENDPOINTS * 2]; // 512 bytes aligned!
uint8_t * endpoint_buffer[NUMBER_OF_PHYSICAL_ENDPOINTS * 2];
uint8_t *endpoint_buffer[NUMBER_OF_PHYSICAL_ENDPOINTS * 2];
uint8_t ep0_buffer[2][MAX_PACKET_SIZE_EP0];
uint8_t ep1_buffer[2][MAX_PACKET_SIZE_EP1];
uint8_t ep2_buffer[2][MAX_PACKET_SIZE_EP2];
@ -96,8 +96,9 @@ static ctrl_xfer_t ctrl_xfer = CTRL_XFER_READY;
static uint32_t Data1 = 0x55555555;
static uint32_t frameNumber() {
return((USB0->FRMNUML | (USB0->FRMNUMH << 8)) & 0x07FF);
static uint32_t frameNumber()
{
return ((USB0->FRMNUML | (USB0->FRMNUMH << 8)) & 0x07FF);
}
USBPhy *get_usb_phy()
@ -126,11 +127,11 @@ void USBPhyHw::init(USBPhyEvents *events)
NVIC_DisableIRQ(USB0_IRQn);
#if (defined(FSL_FEATURE_SOC_MPU_COUNT) && (FSL_FEATURE_SOC_MPU_COUNT > 0U))
MPU->CESR=0;
MPU->CESR = 0;
#endif
#if (defined(FSL_FEATURE_SOC_SYSMPU_COUNT) && (FSL_FEATURE_SOC_SYSMPU_COUNT > 0U))
SYSMPU->CESR=0;
SYSMPU->CESR = 0;
#endif
#if defined(TARGET_KL43Z) || defined(TARGET_K22F) || defined(TARGET_K64F)
@ -150,9 +151,9 @@ void USBPhyHw::init(USBPhyEvents *events)
// USB Module Configuration
// Set BDT Base Register
USB0->BDTPAGE1 = (uint8_t)((uint32_t)bdt>>8);
USB0->BDTPAGE2 = (uint8_t)((uint32_t)bdt>>16);
USB0->BDTPAGE3 = (uint8_t)((uint32_t)bdt>>24);
USB0->BDTPAGE1 = (uint8_t)((uint32_t)bdt >> 8);
USB0->BDTPAGE2 = (uint8_t)((uint32_t)bdt >> 16);
USB0->BDTPAGE3 = (uint8_t)((uint32_t)bdt >> 24);
// Clear interrupt flag
USB0->ISTAT = 0xff;
@ -209,7 +210,7 @@ void USBPhyHw::connect()
void USBPhyHw::disconnect()
{
// disable all endpoints to prevent them from nacking when disconnected
for(int i = 0; i < 16; i++) {
for (int i = 0; i < 16; i++) {
USB0->ENDPOINT[i].ENDPT = 0x00;
}
// disable USB
@ -259,7 +260,7 @@ void USBPhyHw::remote_wakeup()
#define ALLOW_BULK_OR_INT_ENDPOINTS (USB_EP_ATTR_ALLOW_BULK | USB_EP_ATTR_ALLOW_INT)
#define ALLOW_NO_ENDPOINTS 0
const usb_ep_table_t* USBPhyHw::endpoint_table()
const usb_ep_table_t *USBPhyHw::endpoint_table()
{
static const usb_ep_table_t endpoint_table = {
1, // No cost per endpoint - everything allocated up front
@ -349,7 +350,7 @@ void USBPhyHw::ep0_write(uint8_t *buffer, uint32_t size)
// Prepare for next setup packet
endpoint_read_core(EP0OUT, MAX_PACKET_SIZE_EP0);
ctrl_xfer = CTRL_XFER_READY;
}
}
endpoint_write(EP0IN, buffer, size);
// Clear suspend after the setup stage
@ -386,7 +387,7 @@ void USBPhyHw::ep0_stall()
bool USBPhyHw::endpoint_add(usb_ep_t endpoint, uint32_t max_packet, usb_ep_type_t type)
{
uint32_t handshake_flag = 0;
uint8_t * buf;
uint8_t *buf;
if (DESC_TO_PHY(endpoint) > NUMBER_OF_PHYSICAL_ENDPOINTS - 1) {
return false;
@ -406,21 +407,21 @@ bool USBPhyHw::endpoint_add(usb_ep_t endpoint, uint32_t max_packet, usb_ep_type_
// IN endpt -> device to host (TX)
if (DESC_EP_IN(endpoint)) {
bdt[EP_BDT_IDX(log_endpoint, TX, ODD )].address = (uint32_t) buf;
bdt[EP_BDT_IDX(log_endpoint, TX, ODD )].info = 0;
bdt[EP_BDT_IDX(log_endpoint, TX, ODD)].address = (uint32_t) buf;
bdt[EP_BDT_IDX(log_endpoint, TX, ODD)].info = 0;
bdt[EP_BDT_IDX(log_endpoint, TX, EVEN)].address = 0;
USB0->ENDPOINT[log_endpoint].ENDPT |= handshake_flag | // ep handshaking (not if iso endpoint)
USB_ENDPT_EPTXEN_MASK; // en TX (IN) tran
}
// OUT endpt -> host to device (RX)
else {
bdt[EP_BDT_IDX(log_endpoint, RX, ODD )].byte_count = max_packet;
bdt[EP_BDT_IDX(log_endpoint, RX, ODD )].address = (uint32_t) buf;
bdt[EP_BDT_IDX(log_endpoint, RX, ODD )].info = BD_DTS_MASK;
bdt[EP_BDT_IDX(log_endpoint, RX, ODD)].byte_count = max_packet;
bdt[EP_BDT_IDX(log_endpoint, RX, ODD)].address = (uint32_t) buf;
bdt[EP_BDT_IDX(log_endpoint, RX, ODD)].info = BD_DTS_MASK;
bdt[EP_BDT_IDX(log_endpoint, RX, EVEN)].info = 0;
if (log_endpoint == 0) {
// Prepare for setup packet
bdt[EP_BDT_IDX(log_endpoint, RX, ODD )].info |= BD_OWN_MASK;
bdt[EP_BDT_IDX(log_endpoint, RX, ODD)].info |= BD_OWN_MASK;
}
USB0->ENDPOINT[log_endpoint].ENDPT |= handshake_flag | // ep handshaking (not if iso endpoint)
USB_ENDPT_EPRXEN_MASK; // en RX (OUT) tran.
@ -466,8 +467,7 @@ bool USBPhyHw::endpoint_read_core(usb_ep_t endpoint, uint32_t max_packet)
bdt[idx].byte_count = max_packet;
if ((Data1 >> DESC_TO_PHY(endpoint)) & 1) {
bdt[idx].info = BD_OWN_MASK | BD_DTS_MASK | BD_DATA01_MASK;
}
else {
} else {
bdt[idx].info = BD_OWN_MASK | BD_DTS_MASK;
}
@ -491,7 +491,7 @@ bool USBPhyHw::endpoint_read_result_core(usb_ep_t endpoint, uint8_t *data, uint3
{
uint32_t n, sz, idx, setup = 0;
uint8_t not_iso;
uint8_t * ep_buf;
uint8_t *ep_buf;
uint32_t log_endpoint = DESC_TO_LOG(endpoint);
@ -542,7 +542,7 @@ bool USBPhyHw::endpoint_read_result_core(usb_ep_t endpoint, uint8_t *data, uint3
bool USBPhyHw::endpoint_write(usb_ep_t endpoint, uint8_t *data, uint32_t size)
{
uint32_t idx, n;
uint8_t * ep_buf;
uint8_t *ep_buf;
if (DESC_TO_PHY(endpoint) > NUMBER_OF_PHYSICAL_ENDPOINTS - 1) {
return false;
@ -588,7 +588,7 @@ void USBPhyHw::process()
// reset interrupt
if (istat & USB_ISTAT_USBRST_MASK) {
// disable all endpt
for(i = 0; i < 16; i++) {
for (i = 0; i < 16; i++) {
USB0->ENDPOINT[i].ENDPT = 0x00;
}
@ -631,9 +631,10 @@ void USBPhyHw::process()
}
// stall interrupt
if (istat & 1<<7) {
if (USB0->ENDPOINT[0].ENDPT & USB_ENDPT_EPSTALL_MASK)
if (istat & 1 << 7) {
if (USB0->ENDPOINT[0].ENDPT & USB_ENDPT_EPSTALL_MASK) {
USB0->ENDPOINT[0].ENDPT &= ~USB_ENDPT_EPSTALL_MASK;
}
USB0->ISTAT = USB_ISTAT_STALL_MASK;
}
@ -660,9 +661,9 @@ void USBPhyHw::process()
} else {
// OUT packet
if (rx_en && (TOK_PID((EP_BDT_IDX(num, dir, ev_odd))) == OUT_TOKEN)) {
if (num == 0)
if (num == 0) {
events->ep0_out();
else {
} else {
epComplete |= EP(phy_ep);
events->out(PHY_TO_DESC(phy_ep));
}
@ -676,8 +677,7 @@ void USBPhyHw::process()
USB0->ADDR = addr & 0x7F;
set_addr = 0;
}
}
else {
} else {
epComplete |= EP(phy_ep);
events->in(PHY_TO_DESC(phy_ep));
}
@ -688,7 +688,7 @@ void USBPhyHw::process()
}
// sleep interrupt
if (istat & 1<<4) {
if (istat & 1 << 4) {
USB0->ISTAT = USB_ISTAT_SLEEP_MASK;
events->suspend(true);
}
@ -713,7 +713,8 @@ void USBPhyHw::process()
NVIC_EnableIRQ(USB0_IRQn);
}
void USBPhyHw::_usbisr(void) {
void USBPhyHw::_usbisr(void)
{
NVIC_DisableIRQ(USB0_IRQn);
instance->events->start_process();
}

10
usb/device/targets/TARGET_NXP/USBHAL_LPC17.cpp
View File

@ -126,10 +126,10 @@ static USBPhyHw *instance;
static uint32_t opStarted;
static const usb_ep_t ISO_EPS[] = {
0x03, 0x83,
0x06, 0x86,
0x09, 0x89,
0x0C, 0x8C
0x03, 0x83,
0x06, 0x86,
0x09, 0x89,
0x0C, 0x8C
};
static void SIECommand(uint32_t command)
@ -171,7 +171,7 @@ static uint8_t SIEgetDeviceStatus(void)
return SIEReadData(SIE_CMD_GET_DEVICE_STATUS);
}
void SIEsetAddress(uint8_t address, bool enable=true)
void SIEsetAddress(uint8_t address, bool enable = true)
{
// Write SIE device address register
SIECommand(SIE_CMD_SET_ADDRESS);

20
usb/device/targets/TARGET_RENESAS/TARGET_RZ_A1XX/USBPhyHw.h
View File

@ -37,7 +37,7 @@ public:
virtual void sof_disable();
virtual void set_address(uint8_t address);
virtual void remote_wakeup();
virtual const usb_ep_table_t* endpoint_table();
virtual const usb_ep_table_t *endpoint_table();
virtual uint32_t ep0_set_max_packet(uint32_t max_packet);
virtual void ep0_setup_read_result(uint8_t *buffer, uint32_t size);
@ -59,7 +59,7 @@ public:
virtual void process();
private:
#define PIPE_NUM (16)
#define PIPE_NUM (16)
typedef struct {
bool enable;
@ -76,18 +76,18 @@ private:
static void _usbisr(void);
void chg_curpipe(uint16_t pipe, uint16_t isel);
uint16_t is_set_frdy(uint16_t pipe, uint16_t isel);
uint8_t * read_fifo(uint16_t pipe, uint16_t count, uint8_t *read_p);
uint8_t *read_fifo(uint16_t pipe, uint16_t count, uint8_t *read_p);
uint16_t read_data(uint16_t pipe);
void fifo_to_buf(uint16_t pipe);
uint8_t * write_fifo(uint16_t pipe, uint16_t count, uint8_t *write_p);
uint8_t *write_fifo(uint16_t pipe, uint16_t count, uint8_t *write_p);
uint16_t write_data(uint16_t pipe);
void buf_to_fifo(uint16_t pipe);
uint16_t * get_pipectr_reg(uint16_t pipe);
uint16_t * get_pipetre_reg(uint16_t pipe);
uint16_t * get_pipetrn_reg(uint16_t pipe);
uint16_t * get_fifoctr_reg(uint16_t pipe);
uint16_t * get_fifosel_reg(uint16_t pipe);
uint32_t * get_fifo_reg(uint16_t pipe);
uint16_t *get_pipectr_reg(uint16_t pipe);
uint16_t *get_pipetre_reg(uint16_t pipe);
uint16_t *get_pipetrn_reg(uint16_t pipe);
uint16_t *get_fifoctr_reg(uint16_t pipe);
uint16_t *get_fifosel_reg(uint16_t pipe);
uint32_t *get_fifo_reg(uint16_t pipe);
uint16_t get_pid(uint16_t pipe);
void set_mbw(uint16_t pipe, uint16_t data);
void set_pid(uint16_t pipe, uint16_t new_pid);

81
usb/device/targets/TARGET_RENESAS/TARGET_RZ_A1XX/USBPhy_RZ_A1.cpp
View File

@ -502,11 +502,17 @@ bool USBPhyHw::endpoint_read(usb_ep_t endpoint, uint8_t *data, uint32_t size)
/* Set Transaction counter */
p_reg = get_pipetre_reg(pipe);
if (p_reg != NULL) *p_reg |= USB_TRCLR;
if (p_reg != NULL) {
*p_reg |= USB_TRCLR;
}
p_reg = get_pipetrn_reg(pipe);
if (p_reg != NULL) *p_reg = trncnt;
if (p_reg != NULL) {
*p_reg = trncnt;
}
p_reg = get_pipetre_reg(pipe);
if (p_reg != NULL) *p_reg |= USB_TRENB;
if (p_reg != NULL) {
*p_reg |= USB_TRENB;
}
p_reg = get_pipectr_reg(pipe);
/* Buffer Clear */
@ -701,14 +707,12 @@ void USBPhyHw::process()
}
events->ep0_out();
}
}
else if (((ists0 & USB_BEMP) == USB_BEMP) && ((ests & USB_BEMP0) == USB_BEMP0)) {
} else if (((ists0 & USB_BEMP) == USB_BEMP) && ((ests & USB_BEMP0) == USB_BEMP0)) {
/* ==== BEMP PIPE0 ==== */
USB_MX.BEMPSTS = (uint16_t)((~USB_BEMP0) & BEMPSTS_MASK);
events->ep0_in();
}
else if (((ists0 & USB_NRDY) == USB_NRDY) && ((nsts & USB_NRDY0) == USB_NRDY0)) {
} else if (((ists0 & USB_NRDY) == USB_NRDY) && ((nsts & USB_NRDY0) == USB_NRDY0)) {
/* ==== NRDY PIPE0 ==== */
USB_MX.NRDYSTS = (uint16_t)((~USB_NRDY0) & NRDYSTS_MASK);
/* Non processing. */
@ -783,8 +787,7 @@ void USBPhyHw::process()
}
}
}
}
else if ((ists0 & USB_BEMP) == USB_BEMP) {
} else if ((ists0 & USB_BEMP) == USB_BEMP) {
/* ==== BEMP PIPEx ==== */
USB_MX.BEMPSTS = (uint16_t)((~ests) & BEMPSTS_MASK);
@ -806,8 +809,7 @@ void USBPhyHw::process()
}
}
}
}
else if ((ists0 & USB_NRDY) == USB_NRDY) {
} else if ((ists0 & USB_NRDY) == USB_NRDY) {
/* ==== NRDY PIPEx ==== */
USB_MX.NRDYSTS = (uint16_t)((~nsts) & NRDYSTS_MASK);
@ -821,8 +823,7 @@ void USBPhyHw::process()
}
}
}
}
else {
} else {
/* Non processing. */
}
}
@ -892,7 +893,7 @@ uint16_t USBPhyHw::is_set_frdy(uint16_t pipe, uint16_t isel)
return (USB_FIFOERROR);
}
uint8_t * USBPhyHw::read_fifo(uint16_t pipe, uint16_t count, uint8_t *read_p)
uint8_t *USBPhyHw::read_fifo(uint16_t pipe, uint16_t count, uint8_t *read_p)
{
iodefine_reg32_t *p_reg;
uint16_t even;
@ -1018,7 +1019,7 @@ void USBPhyHw::fifo_to_buf(uint16_t pipe)
}
}
uint8_t * USBPhyHw::write_fifo(uint16_t pipe, uint16_t count, uint8_t *write_p)
uint8_t *USBPhyHw::write_fifo(uint16_t pipe, uint16_t count, uint8_t *write_p)
{
iodefine_reg32_t *p_reg;
uint16_t even;
@ -1147,77 +1148,77 @@ void USBPhyHw::buf_to_fifo(uint16_t pipe)
}
}
uint16_t * USBPhyHw::get_pipectr_reg(uint16_t pipe)
uint16_t *USBPhyHw::get_pipectr_reg(uint16_t pipe)
{
if (pipe == USB_PIPE0) {
return (uint16_t *)&(USB_MX.DCPCTR);
return (uint16_t *) & (USB_MX.DCPCTR);
} else {
return (uint16_t *)&(USB_MX.PIPE1CTR) + (pipe - USB_PIPE1);
return (uint16_t *) & (USB_MX.PIPE1CTR) + (pipe - USB_PIPE1);
}
}
uint16_t * USBPhyHw::get_pipetre_reg(uint16_t pipe)
uint16_t *USBPhyHw::get_pipetre_reg(uint16_t pipe)
{
if ((pipe >= USB_PIPE1) && (pipe <= USB_PIPE5)) {
return (uint16_t *)&(USB_MX.PIPE1TRE) + ((pipe - USB_PIPE1) * 2);
return (uint16_t *) & (USB_MX.PIPE1TRE) + ((pipe - USB_PIPE1) * 2);
} else if ((pipe >= USB_PIPE9) && (pipe <= USB_PIPE10)) {
return (uint16_t *)&(USB_MX.PIPE9TRE) + ((pipe - USB_PIPE9) * 2);
return (uint16_t *) & (USB_MX.PIPE9TRE) + ((pipe - USB_PIPE9) * 2);
} else if ((pipe >= USB_PIPE11) && (pipe <= USB_PIPE15)) {
return (uint16_t *)&(USB_MX.PIPEBTRE) + ((pipe - USB_PIPE11) * 2);
return (uint16_t *) & (USB_MX.PIPEBTRE) + ((pipe - USB_PIPE11) * 2);
} else {
return NULL;
}
}
uint16_t * USBPhyHw::get_pipetrn_reg(uint16_t pipe)
uint16_t *USBPhyHw::get_pipetrn_reg(uint16_t pipe)
{
if ((pipe >= USB_PIPE1) && (pipe <= USB_PIPE5)) {
return (uint16_t *)&(USB_MX.PIPE1TRN) + ((pipe - USB_PIPE1) * 2);
return (uint16_t *) & (USB_MX.PIPE1TRN) + ((pipe - USB_PIPE1) * 2);
} else if ((pipe >= USB_PIPE9) && (pipe <= USB_PIPE10)) {
return (uint16_t *)&(USB_MX.PIPE9TRN) + ((pipe - USB_PIPE9) * 2);
return (uint16_t *) & (USB_MX.PIPE9TRN) + ((pipe - USB_PIPE9) * 2);
} else if ((pipe >= USB_PIPE11) && (pipe <= USB_PIPE15)) {
return (uint16_t *)&(USB_MX.PIPEBTRN) + ((pipe - USB_PIPE11) * 2);
return (uint16_t *) & (USB_MX.PIPEBTRN) + ((pipe - USB_PIPE11) * 2);
} else {
return NULL;
}
}
uint16_t * USBPhyHw::get_fifoctr_reg(uint16_t pipe)
uint16_t *USBPhyHw::get_fifoctr_reg(uint16_t pipe)
{
uint16_t fifo_use = PIPE2FIFO(pipe);
if ((fifo_use & USB_FUNCTION_D0FIFO_USE) == USB_FUNCTION_D0FIFO_USE) {
return (uint16_t *)&(USB_MX.D0FIFOCTR);
return (uint16_t *) & (USB_MX.D0FIFOCTR);
} else if ((fifo_use & USB_FUNCTION_D1FIFO_USE) == USB_FUNCTION_D1FIFO_USE) {
return (uint16_t *)&(USB_MX.D1FIFOCTR);
return (uint16_t *) & (USB_MX.D1FIFOCTR);
} else {
return (uint16_t *)&(USB_MX.CFIFOCTR);
return (uint16_t *) & (USB_MX.CFIFOCTR);
}
}
uint16_t * USBPhyHw::get_fifosel_reg(uint16_t pipe)
uint16_t *USBPhyHw::get_fifosel_reg(uint16_t pipe)
{
uint16_t fifo_use = PIPE2FIFO(pipe);
if ((fifo_use & USB_FUNCTION_D0FIFO_USE) == USB_FUNCTION_D0FIFO_USE) {
return (uint16_t *)&(USB_MX.D0FIFOSEL);
return (uint16_t *) & (USB_MX.D0FIFOSEL);
} else if ((fifo_use & USB_FUNCTION_D1FIFO_USE) == USB_FUNCTION_D1FIFO_USE) {
return (uint16_t *)&(USB_MX.D1FIFOSEL);
return (uint16_t *) & (USB_MX.D1FIFOSEL);
} else {
return (uint16_t *)&(USB_MX.CFIFOSEL);
return (uint16_t *) & (USB_MX.CFIFOSEL);
}
}
uint32_t * USBPhyHw::get_fifo_reg(uint16_t pipe)
uint32_t *USBPhyHw::get_fifo_reg(uint16_t pipe)
{
uint16_t fifo_use = PIPE2FIFO(pipe);
if ((fifo_use & USB_FUNCTION_D0FIFO_USE) == USB_FUNCTION_D0FIFO_USE) {
return (uint32_t *)&(USB_MX.D0FIFO);
return (uint32_t *) & (USB_MX.D0FIFO);
} else if ((fifo_use & USB_FUNCTION_D1FIFO_USE) == USB_FUNCTION_D1FIFO_USE) {
return (uint32_t *)&(USB_MX.D1FIFO);
return (uint32_t *) & (USB_MX.D1FIFO);
} else {
return (uint32_t *)&(USB_MX.CFIFO);
return (uint32_t *) & (USB_MX.CFIFO);
}
}
@ -1259,8 +1260,8 @@ void USBPhyHw::set_pid(uint16_t pipe, uint16_t new_pid)
}
break;
case USB_PID_BUF:
if (((old_pid & USB_PID_STALL) == USB_PID_STALL) ||
((old_pid & USB_PID_STALL2) == USB_PID_STALL2)) {
if (((old_pid & USB_PID_STALL) == USB_PID_STALL) ||
((old_pid & USB_PID_STALL2) == USB_PID_STALL2)) {
*p_reg &= (~USB_PID);
*p_reg |= USB_PID_NAK;
}

2
usb/device/targets/TARGET_RENESAS/TARGET_RZ_A1XX/USBPhy_RZ_A1_Def.h
View File

@ -680,7 +680,7 @@
#define USB_CF_RWUPON (0x20u) /* Remote Wake up ON */
#define USB_CF_RWUPOFF (0x00u) /* Remote Wake up OFF */
/* Descriptor length Define */
/* Descriptor length Define */
#define USB_DD_BLENGTH (18u) /* Device Descriptor Length */
#define USB_CD_BLENGTH (9u) /* Configuration Descriptor Length */
#define USB_ID_BLENGTH (9u) /* Interface Descriptor Length */

2
usb/device/targets/TARGET_STM/USBPhyHw.h
View File

@ -63,7 +63,7 @@ public:
virtual void sof_disable();
virtual void set_address(uint8_t address);
virtual void remote_wakeup();
virtual const usb_ep_table_t* endpoint_table();
virtual const usb_ep_table_t *endpoint_table();
virtual uint32_t ep0_set_max_packet(uint32_t max_packet);
virtual void ep0_setup_read_result(uint8_t *buffer, uint32_t size);

74
usb/device/targets/TARGET_STM/USBPhy_STM32.cpp
View File

@ -42,10 +42,10 @@
#define ENDPOINT_NON_ISO (USB_EP_ATTR_ALLOW_BULK | USB_EP_ATTR_ALLOW_INT)
static const uint32_t tx_ep_sizes[NUM_ENDPOINTS] = {
MAX_PACKET_NON_ISO,
MAX_PACKET_NON_ISO,
MAX_PACKET_NON_ISO,
MAX_PACKET_ISO
MAX_PACKET_NON_ISO,
MAX_PACKET_NON_ISO,
MAX_PACKET_NON_ISO,
MAX_PACKET_ISO
};
uint32_t HAL_PCDEx_GetTxFiFo(PCD_HandleTypeDef *hpcd, uint8_t fifo)
@ -53,8 +53,7 @@ uint32_t HAL_PCDEx_GetTxFiFo(PCD_HandleTypeDef *hpcd, uint8_t fifo)
uint32_t len;
if (fifo == 0) {
len = hpcd->Instance->DIEPTXF0_HNPTXFSIZ >> 16;
}
else {
} else {
len = hpcd->Instance->DIEPTXF[fifo - 1] >> 16;
}
return len * 4;
@ -62,7 +61,7 @@ uint32_t HAL_PCDEx_GetTxFiFo(PCD_HandleTypeDef *hpcd, uint8_t fifo)
void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
{
USBPhyHw *priv=((USBPhyHw *)(hpcd->pData));
USBPhyHw *priv = ((USBPhyHw *)(hpcd->pData));
USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
if (priv->sof_enabled) {
priv->events->sof((USBx_DEVICE->DSTS & USB_OTG_DSTS_FNSOF) >> 8);
@ -72,7 +71,7 @@ void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
/* this call at device reception completion on a Out Enpoint */
void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
{
USBPhyHw *priv=((USBPhyHw *)(hpcd->pData));
USBPhyHw *priv = ((USBPhyHw *)(hpcd->pData));
uint8_t endpoint = LOG_OUT_TO_EP(epnum);
priv->epComplete[EP_TO_IDX(endpoint)] = 1;
/* -2 endpoint 0 In out are not in call back list */
@ -86,7 +85,7 @@ void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
/* this is call at device transmission completion on In endpoint */
void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
{
USBPhyHw *priv=((USBPhyHw *)(hpcd->pData));
USBPhyHw *priv = ((USBPhyHw *)(hpcd->pData));
uint8_t endpoint = LOG_IN_TO_EP(epnum);
priv->epComplete[EP_TO_IDX(endpoint)] = 1;
/* -2 endpoint 0 In out are not in call back list */
@ -99,19 +98,19 @@ void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
/* This is call at device set up reception */
void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
{
USBPhyHw *priv=((USBPhyHw *)(hpcd->pData));
USBPhyHw *priv = ((USBPhyHw *)(hpcd->pData));
priv->events->ep0_setup();
}
void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
{
USBPhyHw *priv=((USBPhyHw *)(hpcd->pData));
USBPhyHw *priv = ((USBPhyHw *)(hpcd->pData));
priv->events->suspend(1);
}
void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
{
USBPhyHw *priv=((USBPhyHw *)(hpcd->pData));
USBPhyHw *priv = ((USBPhyHw *)(hpcd->pData));
priv->events->suspend(0);
}
@ -127,15 +126,15 @@ void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
{
USBPhyHw *obj=((USBPhyHw *)(hpcd->pData));
USBPhyHw *obj = ((USBPhyHw *)(hpcd->pData));
unsigned int i;
for(i=0;i<hpcd->Init.dev_endpoints;i++) {
obj->epComplete[2*i]=0;
HAL_PCD_EP_Close(hpcd,IDX_TO_EP(2*i));
HAL_PCD_EP_Flush(hpcd,IDX_TO_EP(2*i));
obj->epComplete[2*i+1]=0;
HAL_PCD_EP_Close(hpcd,IDX_TO_EP(2*i+1));
HAL_PCD_EP_Flush(hpcd,IDX_TO_EP(2*i+1));
for (i = 0; i < hpcd->Init.dev_endpoints; i++) {
obj->epComplete[2 * i] = 0;
HAL_PCD_EP_Close(hpcd, IDX_TO_EP(2 * i));
HAL_PCD_EP_Flush(hpcd, IDX_TO_EP(2 * i));
obj->epComplete[2 * i + 1] = 0;
HAL_PCD_EP_Close(hpcd, IDX_TO_EP(2 * i + 1));
HAL_PCD_EP_Flush(hpcd, IDX_TO_EP(2 * i + 1));
}
obj->endpoint_add(EP0IN, MAX_PACKET_SIZE_EP0, USB_EP_TYPE_CTRL);
@ -299,7 +298,7 @@ void USBPhyHw::init(USBPhyEvents *events)
__HAL_RCC_SYSCFG_CLK_ENABLE();
// Configure PCD and FIFOs
hpcd.pData = (void*)this;
hpcd.pData = (void *)this;
hpcd.State = HAL_PCD_STATE_RESET;
HAL_PCD_Init(&hpcd);
@ -427,7 +426,7 @@ void USBPhyHw::ep0_setup_read_result(uint8_t *buffer, uint32_t size)
size = MAX_PACKET_SIZE_SETUP;
}
memcpy(buffer, hpcd.Setup, size);
memset(hpcd.Setup,0,MAX_PACKET_SIZE_SETUP);
memset(hpcd.Setup, 0, MAX_PACKET_SIZE_SETUP);
}
void USBPhyHw::ep0_read(uint8_t *data, uint32_t size)
@ -435,7 +434,7 @@ void USBPhyHw::ep0_read(uint8_t *data, uint32_t size)
HAL_StatusTypeDef ret;
epComplete[EP_TO_IDX(EP0OUT)] = 2;
ret = HAL_PCD_EP_Receive(&hpcd, EP0OUT, data, size > MAX_PACKET_SIZE_EP0 ? MAX_PACKET_SIZE_EP0 : size);
MBED_ASSERT(ret!=HAL_BUSY);
MBED_ASSERT(ret != HAL_BUSY);
}
uint32_t USBPhyHw::ep0_read_result()
@ -466,12 +465,12 @@ bool USBPhyHw::endpoint_add(usb_ep_t endpoint, uint32_t max_packet, usb_ep_type_
* fifos when endpoints are added or removed causes tests to fail.
*/
if (endpoint & 0x80) {
len = HAL_PCDEx_GetTxFiFo(&hpcd,endpoint & 0x7f);
len = HAL_PCDEx_GetTxFiFo(&hpcd, endpoint & 0x7f);
MBED_ASSERT(len >= max_packet);
}
HAL_StatusTypeDef ret = HAL_PCD_EP_Open(&hpcd, endpoint, max_packet, type);
MBED_ASSERT(ret!=HAL_BUSY);
return (ret == HAL_OK) ? true:false;
MBED_ASSERT(ret != HAL_BUSY);
return (ret == HAL_OK) ? true : false;
}
void USBPhyHw::endpoint_remove(usb_ep_t endpoint)
@ -484,33 +483,33 @@ void USBPhyHw::endpoint_stall(usb_ep_t endpoint)
{
HAL_StatusTypeDef ret;
ret = HAL_PCD_EP_SetStall(&hpcd, endpoint);
MBED_ASSERT(ret!=HAL_BUSY);
MBED_ASSERT(ret != HAL_BUSY);
}
void USBPhyHw::endpoint_unstall(usb_ep_t endpoint)
{
HAL_StatusTypeDef ret;
ret = HAL_PCD_EP_ClrStall(&hpcd, endpoint);
MBED_ASSERT(ret!=HAL_BUSY);
MBED_ASSERT(ret != HAL_BUSY);
}
bool USBPhyHw::endpoint_read(usb_ep_t endpoint, uint8_t *data, uint32_t size)
{
// clean reception end flag before requesting reception
HAL_StatusTypeDef ret = HAL_PCD_EP_Receive(&hpcd, endpoint, data, size);
MBED_ASSERT(ret!=HAL_BUSY);
MBED_ASSERT(ret != HAL_BUSY);
return true;
}
uint32_t USBPhyHw::endpoint_read_result(usb_ep_t endpoint)
{
if (epComplete[EP_TO_IDX(endpoint)]==0) {
if (epComplete[EP_TO_IDX(endpoint)] == 0) {
/* no reception possible !!! */
return 0;
} else if ((epComplete[EP_TO_IDX(endpoint)]!=1)) {
} else if ((epComplete[EP_TO_IDX(endpoint)] != 1)) {
return 0;
}
epComplete[EP_TO_IDX(endpoint)]= 0;
epComplete[EP_TO_IDX(endpoint)] = 0;
return HAL_PCD_EP_GetRxCount(&hpcd, endpoint);;
}
@ -520,9 +519,11 @@ bool USBPhyHw::endpoint_write(usb_ep_t endpoint, uint8_t *data, uint32_t size)
// clean transmission end flag before requesting transmission
epComplete[EP_TO_IDX(endpoint)] = 2;
ret = HAL_PCD_EP_Transmit(&hpcd, endpoint, data, size);
MBED_ASSERT(ret!=HAL_BUSY);
MBED_ASSERT(ret != HAL_BUSY);
// update the status
if (ret != HAL_OK) return false;
if (ret != HAL_OK) {
return false;
}
// fix me return is too simple
return true;
}
@ -530,7 +531,7 @@ bool USBPhyHw::endpoint_write(usb_ep_t endpoint, uint8_t *data, uint32_t size)
void USBPhyHw::endpoint_abort(usb_ep_t endpoint)
{
HAL_StatusTypeDef ret = HAL_PCD_EP_Abort(&hpcd, endpoint);
MBED_ASSERT(ret==HAL_OK);
MBED_ASSERT(ret == HAL_OK);
}
void USBPhyHw::process()
@ -541,7 +542,8 @@ void USBPhyHw::process()
NVIC_EnableIRQ(USBHAL_IRQn);
}
void USBPhyHw::_usbisr(void) {
void USBPhyHw::_usbisr(void)
{
NVIC_DisableIRQ(USBHAL_IRQn);
instance->events->start_process();
}

2
usb/device/targets/TARGET_Template/USBPhyHw.h
View File

@ -37,7 +37,7 @@ public:
virtual void sof_disable();
virtual void set_address(uint8_t address);
virtual void remote_wakeup();
virtual const usb_ep_table_t* endpoint_table();
virtual const usb_ep_table_t *endpoint_table();
virtual uint32_t ep0_set_max_packet(uint32_t max_packet);
virtual void ep0_setup_read_result(uint8_t *buffer, uint32_t size);

3
usb/device/targets/TARGET_Template/USBPhy_template.cpp
View File

@ -304,7 +304,8 @@ void USBPhyHw::process()
NVIC_EnableIRQ(USB_IRQn);
}
void USBPhyHw::_usbisr(void) {
void USBPhyHw::_usbisr(void)
{
NVIC_DisableIRQ(USB_IRQn);
instance->events->start_process();
}