IDF master 3e370c4296

* Fix build compilation due to changes in the HW_TIMER's structs

* Fix compilation warnings and errors with USB

* Update USBCDC.cpp

* Update CMakeLists.txt

* Update HWCDC.cpp

Author: me-no-dev

CMakeLists.txt

@@ -174,7 +174,7 @@ set(includedirs
 set(srcs ${CORE_SRCS} ${LIBRARY_SRCS} ${BLE_SRCS})
 set(priv_includes cores/esp32/libb64)
 set(requires spi_flash mbedtls mdns esp_adc_cal wifi_provisioning nghttp)
-set(priv_requires fatfs nvs_flash app_update spiffs bootloader_support openssl bt esp_ipc)
+set(priv_requires fatfs nvs_flash app_update spiffs bootloader_support openssl bt esp_ipc esp_hid)
 
 idf_component_register(INCLUDE_DIRS ${includedirs} PRIV_INCLUDE_DIRS ${priv_includes} SRCS ${srcs} REQUIRES ${requires} PRIV_REQUIRES ${priv_requires})
 

cores/esp32/FirmwareMSC.cpp

@@ -227,7 +227,7 @@ static esp_err_t msc_update_write(const esp_partition_t *partition, uint32_t off
 //called when error was encountered while updating
 static void msc_update_error(){
   log_e("UPDATE_ERROR: %u", msc_update_bytes_written);
-  arduino_firmware_msc_event_data_t p = {0};
+  arduino_firmware_msc_event_data_t p;
   p.error.size = msc_update_bytes_written;
   arduino_usb_event_post(ARDUINO_FIRMWARE_MSC_EVENTS, ARDUINO_FIRMWARE_MSC_ERROR_EVENT, &p, sizeof(arduino_firmware_msc_event_data_t), portMAX_DELAY);
   msc_update_state = MSC_UPDATE_IDLE;
@@ -251,7 +251,7 @@ static void msc_update_end(){
     msc_update_error();
     return;
   }
-  arduino_firmware_msc_event_data_t p = {0};
+  arduino_firmware_msc_event_data_t p;
   p.end.size = msc_update_entry->file_size;
   arduino_usb_event_post(ARDUINO_FIRMWARE_MSC_EVENTS, ARDUINO_FIRMWARE_MSC_END_EVENT, &p, sizeof(arduino_firmware_msc_event_data_t), portMAX_DELAY);
 }
@@ -289,7 +289,7 @@ static int32_t msc_write(uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_
     }
   } else if(msc_ota_partition && lba >= msc_update_start_sector){
     //handle writes to the region where the new firmware will be uploaded
-    arduino_firmware_msc_event_data_t p = {0};
+    arduino_firmware_msc_event_data_t p;
     if(msc_update_state <= MSC_UPDATE_STARTING && buffer[0] == 0xE9){
       msc_update_state = MSC_UPDATE_RUNNING;
       msc_update_start_sector = lba;
@@ -345,7 +345,7 @@ static int32_t msc_read(uint32_t lba, uint32_t offset, void* buffer, uint32_t bu
 
 static bool msc_start_stop(uint8_t power_condition, bool start, bool load_eject){
   //log_d("power: %u, start: %u, eject: %u", power_condition, start, load_eject);
-  arduino_firmware_msc_event_data_t p = {0};
+  arduino_firmware_msc_event_data_t p;
   p.power.power_condition = power_condition;
   p.power.start = start;
   p.power.load_eject = load_eject;

cores/esp32/HWCDC.cpp

@@ -169,7 +169,7 @@ void HWCDC::begin(unsigned long baud)
 
     usb_serial_jtag_ll_clr_intsts_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY | USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT | USB_SERIAL_JTAG_INTR_BUS_RESET);
     usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY | USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT | USB_SERIAL_JTAG_INTR_BUS_RESET);
-    if(!intr_handle && esp_intr_alloc(ETS_USB_INTR_SOURCE/*ETS_USB_SERIAL_JTAG_INTR_SOURCE*/, 0, hw_cdc_isr_handler, NULL, &intr_handle) != ESP_OK){
+    if(!intr_handle && esp_intr_alloc(ETS_USB_SERIAL_JTAG_INTR_SOURCE, 0, hw_cdc_isr_handler, NULL, &intr_handle) != ESP_OK){
         isr_log_e("HW USB CDC failed to init interrupts");
         end();
         return;

cores/esp32/USB.cpp

@@ -86,30 +86,30 @@ static bool tinyusb_device_suspended = false;
 // Invoked when device is mounted (configured)
 void tud_mount_cb(void){
     tinyusb_device_mounted = true;
-    arduino_usb_event_data_t p = {0};
+    arduino_usb_event_data_t p;
     arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_STARTED_EVENT, &p, sizeof(arduino_usb_event_data_t), portMAX_DELAY);
 }
 
 // Invoked when device is unmounted
 void tud_umount_cb(void){
     tinyusb_device_mounted = false;
-    arduino_usb_event_data_t p = {0};
+    arduino_usb_event_data_t p;
     arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_STOPPED_EVENT, &p, sizeof(arduino_usb_event_data_t), portMAX_DELAY);
 }
 
 // Invoked when usb bus is suspended
 // Within 7ms, device must draw an average of current less than 2.5 mA from bus
 void tud_suspend_cb(bool remote_wakeup_en){
     tinyusb_device_suspended = true;
-    arduino_usb_event_data_t p = {0};
+    arduino_usb_event_data_t p;
     p.suspend.remote_wakeup_en = remote_wakeup_en;
     arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_SUSPEND_EVENT, &p, sizeof(arduino_usb_event_data_t), portMAX_DELAY);
 }
 
 // Invoked when usb bus is resumed
 void tud_resume_cb(void){
     tinyusb_device_suspended = false;
-    arduino_usb_event_data_t p = {0};
+    arduino_usb_event_data_t p;
     arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_RESUME_EVENT, &p, sizeof(arduino_usb_event_data_t), portMAX_DELAY);
 }
 

cores/esp32/USBCDC.cpp

@@ -156,7 +156,7 @@ void USBCDC::_onUnplugged(void){
         connected = false;
         dtr = false;
         rts = false;
-        arduino_usb_cdc_event_data_t p = {0};
+        arduino_usb_cdc_event_data_t p;
         arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_DISCONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
     }
 }
@@ -178,7 +178,7 @@ void USBCDC::_onLineState(bool _dtr, bool _rts){
                 lineState++;
                 if(connected){
                     connected = false;
-                    arduino_usb_cdc_event_data_t p = {0};
+                    arduino_usb_cdc_event_data_t p;
                     arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_DISCONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
                 }
             } else {
@@ -208,14 +208,14 @@ void USBCDC::_onLineState(bool _dtr, bool _rts){
     if(lineState == CDC_LINE_IDLE){
         if(dtr && rts && !connected){
             connected = true;
-            arduino_usb_cdc_event_data_t p = {0};
+            arduino_usb_cdc_event_data_t p;
             arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_CONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
         } else if(!dtr && connected){
             connected = false;
-            arduino_usb_cdc_event_data_t p = {0};
+            arduino_usb_cdc_event_data_t p;
             arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_DISCONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
         }
-        arduino_usb_cdc_event_data_t l = {0};
+        arduino_usb_cdc_event_data_t l;
         l.line_state.dtr = dtr;
         l.line_state.rts = rts;
         arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_LINE_STATE_EVENT, &l, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
@@ -233,7 +233,7 @@ void USBCDC::_onLineCoding(uint32_t _bit_rate, uint8_t _stop_bits, uint8_t _pari
             data_bits = _data_bits;
             stop_bits = _stop_bits;
             parity = _parity;
-            arduino_usb_cdc_event_data_t p = {0};
+            arduino_usb_cdc_event_data_t p;
             p.line_coding.bit_rate = bit_rate;
             p.line_coding.data_bits = data_bits;
             p.line_coding.stop_bits = stop_bits;
@@ -251,13 +251,13 @@ void USBCDC::_onRX(){
             return;
         }
     }
-    arduino_usb_cdc_event_data_t p = {0};
+    arduino_usb_cdc_event_data_t p;
     p.rx.len = count;
     arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_RX_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
 }
 
 void USBCDC::_onTX(){
-    arduino_usb_cdc_event_data_t p = {0};
+    arduino_usb_cdc_event_data_t p;
     arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_TX_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
 }
 

cores/esp32/esp32-hal-timer.c

@@ -90,17 +90,10 @@ typedef void (*voidFuncPtr)(void);
 static voidFuncPtr __timerInterruptHandlers[4] = {0,0,0,0};
 
 void ARDUINO_ISR_ATTR __timerISR(void * arg){
-#if CONFIG_IDF_TARGET_ESP32
     uint32_t s0 = TIMERG0.int_st_timers.val;
     uint32_t s1 = TIMERG1.int_st_timers.val;
     TIMERG0.int_clr_timers.val = s0;
     TIMERG1.int_clr_timers.val = s1;
-#else
-    uint32_t s0 = TIMERG0.int_st.val;
-    uint32_t s1 = TIMERG1.int_st.val;
-    TIMERG0.int_clr.val = s0;
-    TIMERG1.int_clr.val = s1;
-#endif
     uint8_t status = (s1 & 3) << 2 | (s0 & 3);
     uint8_t i = 4;
     //restart the timers that should autoreload
@@ -239,19 +232,19 @@ hw_timer_t * timerBegin(uint8_t num, uint16_t divider, bool countUp){
     }
     timer->dev->config.enable = 0;
     if(timer->group) {
-        TIMERG1.int_ena.val &= ~BIT(timer->timer);
 #if CONFIG_IDF_TARGET_ESP32
-            TIMERG1.int_clr_timers.val |= BIT(timer->timer);
+        TIMERG1.int_ena.val &= ~BIT(timer->timer);
 #else
-            TIMERG1.int_clr.val = BIT(timer->timer);
+        TIMERG1.int_ena_timers.val &= ~BIT(timer->timer);
 #endif
+        TIMERG1.int_clr_timers.val |= BIT(timer->timer);
     } else {
-        TIMERG0.int_ena.val &= ~BIT(timer->timer);
 #if CONFIG_IDF_TARGET_ESP32
-            TIMERG0.int_clr_timers.val |= BIT(timer->timer);
+        TIMERG0.int_ena.val &= ~BIT(timer->timer);
 #else
-            TIMERG0.int_clr.val = BIT(timer->timer);
+        TIMERG0.int_ena_timers.val &= ~BIT(timer->timer);
 #endif
+        TIMERG0.int_clr_timers.val |= BIT(timer->timer);
     }
 #ifdef TIMER_GROUP_SUPPORTS_XTAL_CLOCK
     timer->dev->config.use_xtal = 0;
@@ -289,19 +282,19 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
         timer->dev->config.edge_int_en = 0;
         timer->dev->config.alarm_en = 0;
         if(timer->num & 2){
-            TIMERG1.int_ena.val &= ~BIT(timer->timer);
 #if CONFIG_IDF_TARGET_ESP32
-            TIMERG1.int_clr_timers.val |= BIT(timer->timer);
+            TIMERG1.int_ena.val &= ~BIT(timer->timer);
 #else
-            TIMERG1.int_clr.val = BIT(timer->timer);
+            TIMERG1.int_ena_timers.val &= ~BIT(timer->timer);
 #endif
+            TIMERG1.int_clr_timers.val |= BIT(timer->timer);
         } else {
-            TIMERG0.int_ena.val &= ~BIT(timer->timer);
 #if CONFIG_IDF_TARGET_ESP32
-            TIMERG0.int_clr_timers.val |= BIT(timer->timer);
+            TIMERG0.int_ena.val &= ~BIT(timer->timer);
 #else
-            TIMERG0.int_clr.val = BIT(timer->timer);
+            TIMERG0.int_ena_timers.val &= ~BIT(timer->timer);
 #endif
+            TIMERG0.int_clr_timers.val |= BIT(timer->timer);
         }
         __timerInterruptHandlers[timer->num] = NULL;
     } else {
@@ -333,9 +326,17 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
             intr_matrix_set(esp_intr_get_cpu(intr_handle), intr_source, esp_intr_get_intno(intr_handle));
         }
         if(timer->group){
+#if CONFIG_IDF_TARGET_ESP32
             TIMERG1.int_ena.val |= BIT(timer->timer);
+#else
+            TIMERG1.int_ena_timers.val |= BIT(timer->timer);
+#endif
         } else {
+#if CONFIG_IDF_TARGET_ESP32
             TIMERG0.int_ena.val |= BIT(timer->timer);
+#else
+            TIMERG0.int_ena_timers.val |= BIT(timer->timer);
+#endif
         }
     }
     if(intr_handle){

libraries/USB/src/USBHID.cpp

@@ -230,7 +230,7 @@ uint8_t const * tud_hid_descriptor_report_cb(uint8_t instance){
 // protocol is either HID_PROTOCOL_BOOT (0) or HID_PROTOCOL_REPORT (1)
 void tud_hid_set_protocol_cb(uint8_t instance, uint8_t protocol){
     log_v("instance: %u, protocol:%u", instance, protocol);
-    arduino_usb_hid_event_data_t p = {0};
+    arduino_usb_hid_event_data_t p;
     p.instance = instance;
     p.set_protocol.protocol = protocol;
     arduino_usb_event_post(ARDUINO_USB_HID_EVENTS, ARDUINO_USB_HID_SET_PROTOCOL_EVENT, &p, sizeof(arduino_usb_hid_event_data_t), portMAX_DELAY);
@@ -241,7 +241,7 @@ void tud_hid_set_protocol_cb(uint8_t instance, uint8_t protocol){
 // - Idle Rate > 0 : skip duplication, but send at least 1 report every idle rate (in unit of 4 ms).
 bool tud_hid_set_idle_cb(uint8_t instance, uint8_t idle_rate){
     log_v("instance: %u, idle_rate:%u", instance, idle_rate);
-    arduino_usb_hid_event_data_t p = {0};
+    arduino_usb_hid_event_data_t p;
     p.instance = instance;
     p.set_idle.idle_rate = idle_rate;
     arduino_usb_event_post(ARDUINO_USB_HID_EVENTS, ARDUINO_USB_HID_SET_IDLE_EVENT, &p, sizeof(arduino_usb_hid_event_data_t), portMAX_DELAY);

libraries/USB/src/USBHIDKeyboard.cpp

@@ -61,7 +61,7 @@ void USBHIDKeyboard::onEvent(arduino_usb_hid_keyboard_event_t event, esp_event_h
 
 void USBHIDKeyboard::_onOutput(uint8_t report_id, const uint8_t* buffer, uint16_t len){
     if(report_id == HID_REPORT_ID_KEYBOARD){
-        arduino_usb_hid_keyboard_event_data_t p = {0};
+        arduino_usb_hid_keyboard_event_data_t p;
         p.leds = buffer[0];
         arduino_usb_event_post(ARDUINO_USB_HID_KEYBOARD_EVENTS, ARDUINO_USB_HID_KEYBOARD_LED_EVENT, &p, sizeof(arduino_usb_hid_keyboard_event_data_t), portMAX_DELAY);
     }

libraries/USB/src/USBHIDVendor.cpp

@@ -124,7 +124,7 @@ uint16_t USBHIDVendor::_onGetFeature(uint8_t report_id, uint8_t* buffer, uint16_
         return 0;
     }
     memcpy(buffer, feature, len);
-    arduino_usb_hid_vendor_event_data_t p = {0};
+    arduino_usb_hid_vendor_event_data_t p;
     p.buffer = feature;
     p.len = len;
     arduino_usb_event_post(ARDUINO_USB_HID_VENDOR_EVENTS, ARDUINO_USB_HID_VENDOR_GET_FEATURE_EVENT, &p, sizeof(arduino_usb_hid_vendor_event_data_t), portMAX_DELAY);
@@ -136,7 +136,7 @@ void USBHIDVendor::_onSetFeature(uint8_t report_id, const uint8_t* buffer, uint1
         return;
     }
     memcpy(feature, buffer, len);
-    arduino_usb_hid_vendor_event_data_t p = {0};
+    arduino_usb_hid_vendor_event_data_t p;
     p.buffer = feature;
     p.len = len;
     arduino_usb_event_post(ARDUINO_USB_HID_VENDOR_EVENTS, ARDUINO_USB_HID_VENDOR_SET_FEATURE_EVENT, &p, sizeof(arduino_usb_hid_vendor_event_data_t), portMAX_DELAY);
@@ -153,7 +153,7 @@ void USBHIDVendor::_onOutput(uint8_t report_id, const uint8_t* buffer, uint16_t
             break;
         }
     }
-    arduino_usb_hid_vendor_event_data_t p = {0};
+    arduino_usb_hid_vendor_event_data_t p;
     p.buffer = buffer;
     p.len = len;
     arduino_usb_event_post(ARDUINO_USB_HID_VENDOR_EVENTS, ARDUINO_USB_HID_VENDOR_OUTPUT_EVENT, &p, sizeof(arduino_usb_hid_vendor_event_data_t), portMAX_DELAY);

libraries/USB/src/USBVendor.cpp

@@ -146,7 +146,7 @@ void USBVendor::_onRX(const uint8_t* buffer, size_t len){
             break;
         }
     }
-    arduino_usb_vendor_event_data_t p = {0};
+    arduino_usb_vendor_event_data_t p;
     p.data.len = len;
     arduino_usb_event_post(ARDUINO_USB_VENDOR_EVENTS, ARDUINO_USB_VENDOR_DATA_EVENT, &p, sizeof(arduino_usb_vendor_event_data_t), portMAX_DELAY);
 }